/** * {@inheritDoc} */ protected function execute(InputInterface $input, OutputInterface $output) { $session = $this->getPhpcrSession(); $dumperHelper = $this->getPhpcrConsoleDumperHelper(); // node to dump $identifier = $input->getArgument('identifier'); // whether to dump node uuid $options = array(); $options['dump_uuids'] = $input->hasParameterOption('--identifiers'); $options['ref_format'] = $input->getOption('ref-format'); $options['show_props'] = $input->hasParameterOption('--props'); $options['show_sys_nodes'] = $input->hasParameterOption('--sys-nodes'); $options['max_line_length'] = $input->getOption('max_line_length'); if (null !== $options['ref_format'] && !in_array($options['ref_format'], array('uuid', 'path'))) { throw new \Exception('The ref-format option must be set to either "path" or "uuid"'); } $walker = $dumperHelper->getTreeWalker($output, $options); try { if (UUIDHelper::isUUID($identifier)) { $node = $session->getNodeByIdentifier($identifier); } else { $node = $session->getNode($identifier); } $walker->traverse($node, $input->getOption('depth')); } catch (RepositoryException $e) { if ($e instanceof PathNotFoundException || $e instanceof ItemNotFoundException) { $output->writeln("<error>Path '{$identifier}' does not exist</error>"); } else { throw $e; } return 1; } return 0; }
public function testIsUUID() { $this->assertTrue(UUIDHelper::isUUID('550e8400-e29b-41d4-a716-446655440000')); $this->assertTrue(UUIDHelper::isUUID('00000000-0000-0000-C000-000000000046')); $this->assertFalse(UUIDHelper::isUUID('not a uuid')); $this->assertFalse(UUIDHelper::isUUID('123456')); }
public function testCommandIdentifier() { $uuid = UUIDHelper::generateUUID(); $this->dumperHelper->expects($this->once())->method('getTreeWalker')->will($this->returnValue($this->treeWalker)); $this->session->expects($this->once())->method('getNodeByIdentifier')->with($uuid)->will($this->returnValue($this->node1)); $this->treeWalker->expects($this->once())->method('traverse')->with($this->node1); $this->executeCommand('phpcr:node:dump', array('identifier' => $uuid)); }
/** * {@inheritdoc} */ public function createNodeForDocument($document, NodeInterface $parentNode, $name) { $metadata = $this->metadataFactory->getMetadataForClass(get_class($document)); $node = $parentNode->addNode($name); $node->addMixin($metadata->getPhpcrType()); $node->setProperty('jcr:uuid', UUIDHelper::generateUUID()); return $node; }
private function processNode(Node $node) { if (false === $node->hasProperty(Storage::JCR_UUID)) { return; } $jcrUuid = UUIDHelper::generateUUID(); $node->setProperty(Storage::JCR_UUID, $jcrUuid, 'String'); }
/** * @covers Doctrine\ODM\PHPCR\DocumentManager::findTranslation */ public function testFindTranslation() { $fakeUuid = \PHPCR\Util\UUIDHelper::generateUUID(); $session = $this->getMockForAbstractClass('PHPCR\\SessionInterface', array('getNodeByIdentifier')); $session->expects($this->once())->method('getNodeByIdentifier')->will($this->throwException(new \PHPCR\ItemNotFoundException(sprintf('403: %s', $fakeUuid)))); $config = new \Doctrine\ODM\PHPCR\Configuration(); $dm = DocumentManager::create($session, $config); $nonExistent = $dm->findTranslation(null, $fakeUuid, 'en'); $this->assertNull($nonExistent); }
private function getOrCreateInternalUuid($path) { if (!$this->pathRegistry->hasPath($path)) { $internalUuid = UUIDHelper::generateUUID(); } else { $internalUuid = $this->pathRegistry->getUuid($path); } if (!$internalUuid) { throw new \RuntimeException('Failed to determine internal UUID'); } return $internalUuid; }
public function reverseTransform($uuid) { if (!$uuid) { return; } if (!UUIDHelper::isUuid($uuid)) { throw new TransformationFailedException(sprintf('Given UUID is not a UUID, given: "%s"', $uuid)); } $document = $this->documentManager->find($uuid); if (null === $document) { throw new TransformationFailedException(sprintf('Could not find document with UUID "%s"', $uuid)); } return $document; }
private function resolveSiblingName($siblingId, NodeInterface $parentNode, NodeInterface $node) { if (null === $siblingId) { return; } $siblingPath = $siblingId; if (UUIDHelper::isUUID($siblingId)) { $siblingPath = $this->nodeManager->find($siblingId)->getPath(); } if ($siblingPath !== null && PathHelper::getParentPath($siblingPath) !== $parentNode->getPath()) { throw new DocumentManagerException(sprintf('Cannot reorder documents which are not siblings. Trying to reorder "%s" to "%s"', $node->getPath(), $siblingPath)); } if (null !== $siblingPath) { return PathHelper::getNodeName($siblingPath); } return $node->getName(); }
public function testFindManyWithNonExistingUuuid() { $user = new TestUser(); $user->username = '******'; $user->id = '/functional/test'; $this->dm->persist($user); $this->dm->flush(); $this->dm->clear(); $actualUuid = $user->uuid; $unusedUuid = UUIDHelper::generateUUID(); $this->assertNotNull($this->dm->find(get_class($user), $user->id)); $this->assertNotNull($this->dm->find(get_class($user), $actualUuid)); $this->assertNull($this->dm->find(get_class($user), $unusedUuid)); $uuids = array($actualUuid, $unusedUuid); $documents = $this->dm->findMany(get_class($user), $uuids); $this->assertEquals(1, count($documents)); }
public function testCreate() { $refTestObj = new RefTestObj(); $refRefTestObj = new RefRefTestObj(); $refTestObj->id = "/functional/refTestObj"; $refRefTestObj->id = "/functional/refRefTestObj"; $refRefTestObj->name = "referenced"; $refTestObj->reference = $refRefTestObj; $this->dm->persist($refTestObj); $this->dm->flush(); $this->dm->clear(); $this->assertTrue($this->session->getNode('/functional')->hasNode('refRefTestObj')); $refRefTestNode = $this->session->getNode('/functional/refRefTestObj'); $this->assertEquals('referenced', $refRefTestNode->getProperty('name')->getString()); $refTestNode = $this->session->getNode('/functional/refTestObj'); $this->assertTrue($refTestNode->hasProperty('myReference')); $this->assertEquals($refRefTestNode->getIdentifier(), $refTestNode->getProperty('myReference')->getString()); $this->assertTrue(UUIDHelper::isUUID($refTestNode->getProperty('myReference')->getString())); }
public function execute(InputInterface $input, OutputInterface $output) { $session = $this->get('phpcr.session'); $pathHelper = $this->get('helper.path'); $path = $session->getAbsPath($input->getArgument('path')); $value = $input->getArgument('value'); $type = $input->getOption('type'); $nodePath = $pathHelper->getParentPath($path); $propName = $pathHelper->getNodeName($path); $nodes = $session->findNodes($nodePath); foreach ($nodes as $node) { $intType = null; if ($type) { $intType = PropertyType::valueFromName($type); if ($intType === PropertyType::REFERENCE || $intType === PropertyType::WEAKREFERENCE) { // convert path to UUID if (false === UUIDHelper::isUuid($value)) { $path = $value; try { $targetNode = $session->getNode($path); $value = $targetNode->getIdentifier(); } catch (PathNotFoundException $e) { } if (null === $value) { throw new \InvalidArgumentException(sprintf('Node at path "%s" specified for reference is not referenceable', $path)); } } } } else { try { $property = $node->getProperty($propName); $intType = $property->getType(); } catch (PathNotFoundException $e) { // property doesn't exist and no type specified, default to string $intType = PropertyType::STRING; } } $node->setProperty($propName, $value, $intType); } }
public function addNode($workspaceName, \DOMElement $node) { $properties = $this->getAttributes($node); $uuid = isset($properties['jcr:uuid']['value'][0]) ? (string) $properties['jcr:uuid']['value'][0] : UUIDHelper::generateUUID(); $this->ids[$uuid] = $id = isset($this->expectedNodes[$uuid]) ? $this->expectedNodes[$uuid] : self::$idCounter++; $dom = new \DOMDocument('1.0', 'UTF-8'); $phpcrNode = $dom->createElement('sv:node'); foreach ($this->namespaces as $namespace => $uri) { $phpcrNode->setAttribute('xmlns:' . $namespace, $uri); } $dom->appendChild($phpcrNode); foreach ($properties as $propertyName => $propertyData) { if ($propertyName == 'jcr:uuid') { continue; } if (!isset($this->jcrTypes[$propertyData['type']])) { throw new \InvalidArgumentException('"' . $propertyData['type'] . '" is not a valid JCR type.'); } $phpcrNode->appendChild($this->createPropertyNode($workspaceName, $propertyName, $propertyData, $id, $dom, $phpcrNode)); } list($parentPath, $childPath) = $this->getPath($node); $namespace = ''; $name = $node->getAttributeNS($this->namespaces['sv'], 'name'); if (count($parts = explode(':', $name, 2)) == 2) { list($namespace, $name) = $parts; } if ($namespace == 'jcr' && $name == 'root') { $id = 1; $childPath = '/'; $parentPath = ''; $name = ''; $namespace = ''; } $this->addRow('phpcr_nodes', array('id' => $id, 'path' => $childPath, 'parent' => $parentPath, 'local_name' => $name, 'namespace' => $namespace, 'workspace_name' => $workspaceName, 'identifier' => $uuid, 'type' => $properties['jcr:primaryType']['value'][0], 'props' => $dom->saveXML(), 'depth' => PathHelper::getPathDepth($childPath), 'sort_order' => $id - 2)); return $this; }
/** * {@inheritdoc} */ public function write(NodeInterface $node, PropertyInterface $property, $userId, $webspaceKey, $languageCode, $segmentKey) { $snippetReferences = []; $values = $property->getValue(); $values = is_array($values) ? $values : []; foreach ($values as $value) { if ($value instanceof SnippetBridge) { $snippetReferences[] = $value->getUuid(); } elseif (is_array($value) && array_key_exists('uuid', $value) && UUIDHelper::isUUID($value['uuid'])) { $snippetReferences[] = $value['uuid']; } elseif (UUIDHelper::isUUID($value)) { $snippetReferences[] = $value; } else { throw new \InvalidArgumentException(sprintf('Property value must either be a UUID or a Snippet, "%s" given.', gettype($value))); } } $node->setProperty($property->getName(), $snippetReferences, PropertyType::REFERENCE); }
private function setMixins(Mapping\ClassMetadata $metadata, NodeInterface $node) { if ($metadata->versionable === 'full') { $node->addMixin('mix:versionable'); } else { if ($metadata->versionable === 'simple') { $node->addMixin('mix:simpleVersionable'); } if ($metadata->referenceable) { $node->addMixin('mix:referenceable'); } } // we manually set the uuid to allow creating referenced and referencing document without flush in between. if ($node->isNodeType('mix:referenceable') && !$node->hasProperty('jcr:uuid')) { // TODO do we need to check with the storage backend if the generated id really is unique? $node->setProperty('jcr:uuid', UUIDHelper::generateUUID()); } }
/** * Get the closure for the UUID generation. * * @since 1.1 * @return callable a UUID generator */ public function getUuidGenerator() { return isset($this->attributes['uuidGenerator']) ? $this->attributes['uuidGenerator'] : function () { return UUIDHelper::generateUUID(); }; }
/** * @return callable a uuid generator function. */ protected function getUuidGenerator() { if (!$this->uuidGenerator) { $this->uuidGenerator = function() { return UUIDHelper::generateUUID(); }; } return $this->uuidGenerator; }
public function testLoadShallowStructureByNode() { $node = $this->session->getNode($this->snippet1OriginalPath); $snippet = $this->contentMapper->loadShallowStructureByNode($node, 'de', 'sulu_io'); $this->assertEquals('animal', $snippet->getKey()); $this->assertTrue(UUIDHelper::isUUID($snippet->getUuid())); }
/** * @return string a universally unique id. */ protected function generateUuid() { return UUIDHelper::generateUUID(); }
public function execute(InputInterface $input, OutputInterface $output) { $session = $this->get('phpcr.session'); $path = $input->getArgument('path'); if (UUIDHelper::isUUID($path)) { // If the node is a UUID, then just get it $node = $session->getNodeByIdentifier($path); } else { $path = $session->getAbsPath($path); // Otherwise it is a path which may or may not exist $parentPath = $this->get('helper.path')->getParentPath($path); $nodeName = $this->get('helper.path')->getNodeName($path); $type = $input->getOption('type'); try { // if it exists, then great $node = $session->getNodeByPathOrIdentifier($path); } catch (PathNotFoundException $e) { // if it doesn't exist then we create it $parentNode = $session->getNode($parentPath); $node = $parentNode->addNode($nodeName, $type); } } $editor = $this->get('helper.editor'); $dialog = $this->get('helper.question'); $skipBinary = true; $noRecurse = true; // for now we only support YAML $encoders = [new YamlEncoder()]; $nodeNormalizer = new NodeNormalizer(); $serializer = new Serializer([$nodeNormalizer], $encoders); $outStr = $serializer->serialize($node, 'yaml'); $tryAgain = false; $message = ''; $error = ''; $notes = implode("\n", $nodeNormalizer->getNotes()); do { $message = ''; if ($error) { $template = <<<'EOT' Error encounred: %s EOT; $message .= sprintf($template, $error); } if ($notes) { $template = <<<'EOT' NOTE: %s EOT; $message .= sprintf($template, $notes); } // string pass to editor if ($message) { $inStr = $editor->fromStringWithMessage($outStr, $message, '# ', 'yml'); } else { $inStr = $editor->fromString($outStr, 'yml'); } try { $norm = $serializer->deserialize($inStr, 'PHPCR\\NodeInterface', 'yaml', ['node' => $node]); $tryAgain = false; } catch (\Exception $e) { $error = $e->getMessage(); $output->writeln('<error>' . $error . '</error>'); if (false === $input->getOption('no-interaction')) { $tryAgain = $dialog->ask($input, $output, new ConfirmationQuestion('Do you want to try again? (y/n)')); } $outStr = $inStr; } } while ($tryAgain == true); if ($error) { return 1; } return 0; }
public function testGetRoutesByNamesUuid() { $uuid1 = UUIDHelper::generateUUID(); $uuid2 = UUIDHelper::generateUUID(); $paths = array($uuid1, $uuid2); $route1 = new Route('/test-route'); $route2 = new Route('/other-route'); $routes = new ArrayCollection(); $routes->set($uuid1, $route1); $routes->set($uuid2, $route2); $this->dmMock->expects($this->once())->method('findMany')->with(null, $paths)->will($this->returnValue($routes)); $uow = $this->buildMock('Doctrine\\ODM\\PHPCR\\UnitOfWork'); $this->dmMock->expects($this->any())->method('getUnitOfWork')->will($this->returnValue($uow)); $uow->expects($this->at(0))->method('getDocumentId')->with($route1)->will($this->returnValue('/cms/routes/test-route')); $uow->expects($this->at(1))->method('getDocumentId')->with($route2)->will($this->returnValue('/cms/routes/other-route')); $this->candidatesMock->expects($this->at(0))->method('isCandidate')->with('/cms/routes/test-route')->will($this->returnValue(true)); $this->candidatesMock->expects($this->at(1))->method('isCandidate')->with('/cms/routes/other-route')->will($this->returnValue(false)); $routeProvider = new RouteProvider($this->managerRegistryMock, $this->candidatesMock); $routeProvider->setManagerName('default'); $routes = $routeProvider->getRoutesByNames($paths); $this->assertCount(1, $routes); }
/** * Get subject * * Overridden to allow a broader set of valid characters in the ID, and * if the ID is not a UUID, to call absolutizePath on the ID. * * @return mixed */ public function getSubject() { if ($this->subject === null && $this->request) { $id = $this->request->get($this->getIdParameter()); if (!preg_match('#^[0-9A-Za-z/\\-_]+$#', $id)) { $this->subject = false; } else { if (!UUIDHelper::isUUID($id)) { $id = PathHelper::absolutizePath($id, '/'); } $this->subject = $this->getModelManager()->find($this->getClass(), $id); } } return $this->subject; }
/** * TODO: we should move that into the common Jackalope BaseTransport or as new method of NodeType * it will be helpful for other implementations * * Validate this node with the nodetype and generate not yet existing * autogenerated properties as necessary * * @param Node $node * @param NodeType $def */ private function validateNode(Node $node, NodeType $def) { foreach ($def->getDeclaredChildNodeDefinitions() as $childDef) { /* @var $childDef \PHPCR\NodeType\NodeDefinitionInterface */ if (!$node->hasNode($childDef->getName())) { if ('*' === $childDef->getName()) { continue; } if ($childDef->isMandatory() && !$childDef->isAutoCreated()) { throw new RepositoryException("Child " . $childDef->getName() . " is mandatory, but is not present while " . "saving " . $def->getName() . " at " . $node->getPath()); } if ($childDef->isAutoCreated()) { throw new NotImplementedException("Auto-creation of child node '" . $def->getName() . "#" . $childDef->getName() . "' is not yet supported in DoctrineDBAL transport."); } } } foreach ($def->getDeclaredPropertyDefinitions() as $propertyDef) { /* @var $propertyDef \PHPCR\NodeType\PropertyDefinitionInterface */ if ('*' == $propertyDef->getName()) { continue; } if (!$node->hasProperty($propertyDef->getName())) { if ($propertyDef->isMandatory() && !$propertyDef->isAutoCreated()) { throw new RepositoryException("Property " . $propertyDef->getName() . " is mandatory, but is not present while " . "saving " . $def->getName() . " at " . $node->getPath()); } if ($propertyDef->isAutoCreated()) { switch ($propertyDef->getName()) { case 'jcr:uuid': $value = UUIDHelper::generateUUID(); break; case 'jcr:createdBy': case 'jcr:lastModifiedBy': $value = $this->credentials->getUserID(); break; case 'jcr:created': case 'jcr:lastModified': $value = new \DateTime(); break; case 'jcr:etag': // TODO: http://www.day.com/specs/jcr/2.0/3_Repository_Model.html#3.7.12.1%20mix:etag $value = 'TODO: generate from binary properties of this node'; break; default: $defaultValues = $propertyDef->getDefaultValues(); if ($propertyDef->isMultiple()) { $value = $defaultValues; } elseif (isset($defaultValues[0])) { $value = $defaultValues[0]; } else { // When implementing versionable or activity, we need to handle more properties explicitly throw new RepositoryException('No default value for autocreated property ' . $propertyDef->getName() . ' at ' . $node->getPath()); } } $node->setProperty($propertyDef->getName(), $value, $propertyDef->getRequiredType()); } } } foreach ($node->getProperties() as $property) { $this->assertValidProperty($property); } }
/** * {@inheritDoc} * * @throws InvalidItemStateException * @throws NoSuchWorkspaceException * * @api */ public function getNode() { $this->checkState(); $values = $this->isMultiple() ? $this->value : array($this->value); $results = array(); switch ($this->type) { case PropertyType::REFERENCE: $results = $this->getReferencedNodes($values, false); break; case PropertyType::WEAKREFERENCE: $results = $this->getReferencedNodes($values, true); break; case PropertyType::STRING: foreach ($values as $value) { if (UUIDHelper::isUUID($value)) { $results[] = $this->objectManager->getNodeByIdentifier($value); } else { $results[] = $this->objectManager->getNode($value, $this->parentPath); } } break; case PropertyType::PATH: case PropertyType::NAME: foreach ($values as $value) { // OPTIMIZE: use objectManager->getNodes instead of looping (but paths need to be absolute then) $results[] = $this->objectManager->getNode($value, $this->parentPath); } break; default: throw new ValueFormatException('Property is not a REFERENCE, WEAKREFERENCE or PATH (or convertible to PATH)'); } return $this->isMultiple() ? $results : reset($results); }
public function testGetReferencedUuids() { $pageNode = $this->session->getNode('/cmf/sulu_io/contents/hotels'); $pageStructure = $this->contentMapper->loadByNode($pageNode, 'en', 'sulu_io', true, false, false); $property = $pageStructure->getProperty('hotels'); $uuids = $this->contentType->getReferencedUuids($property); $this->assertCount(2, $uuids); foreach ($uuids as $uuid) { $this->assertTrue(UUIDHelper::isUuid($uuid)); } }
/** * Get the database primary key for node. * * @param string $identifier Path of the identifier * @param string $workspaceName To overwrite the current workspace * * @return bool|string The database id */ private function getSystemIdForNode($identifier, $workspaceName = null) { if (null === $workspaceName) { $workspaceName = $this->workspaceName; } if (UUIDHelper::isUUID($identifier)) { $query = 'SELECT id FROM phpcr_nodes WHERE identifier = ? AND workspace_name = ?'; } else { if ($this->getConnection()->getDriver() instanceof \Doctrine\DBAL\Driver\PDOMySql\Driver) { $query = 'SELECT id FROM phpcr_nodes WHERE path COLLATE utf8_bin = ? AND workspace_name = ?'; } else { $query = 'SELECT id FROM phpcr_nodes WHERE path = ? AND workspace_name = ?'; } } $nodeId = $this->getConnection()->fetchColumn($query, array($identifier, $workspaceName)); return $nodeId ?: false; }
public function findNodes($patternOrId) { if (true === UUIDHelper::isUUID($patternOrId)) { return $this->getNodeByIdentifier($patternOrId); } $res = $this->finder->find($this->getAbsPath($patternOrId)); return $res; }
/** * {@inheritDoc} */ public function getRoutesByNames($names = null) { if (null === $names) { return $this->getAllRoutes(); } $candidates = array(); foreach ($names as $key => $name) { if (UUIDHelper::isUUID($name) || $this->candidatesStrategy->isCandidate($name)) { $candidates[$key] = $name; } } if (!$candidates) { return array(); } /** @var $dm DocumentManager */ $dm = $this->getObjectManager(); $documents = $dm->findMany($this->className, $candidates); foreach ($documents as $key => $document) { if (UUIDHelper::isUUID($key) && !$this->candidatesStrategy->isCandidate($this->getObjectManager()->getUnitOfWork()->getDocumentId($document))) { // this uuid pointed out of our path. can only determine after fetching the document unset($documents[$key]); } if (!$document instanceof SymfonyRoute) { // we follow the logic of DocumentManager::findMany and do not throw an exception unset($documents[$key]); } } return $documents; }
/** * Persist new document, marking it managed and generating the id and the node. * * This method is either called through `DocumentManager#persist()` or during `DocumentManager#flush()`, * when persistence by reachability is applied. * * @param ClassMetadata $class * @param object $document */ public function persistNew(ClassMetadata $class, $document, $overrideIdGenerator = null, $parent = null) { if ($invoke = $this->eventListenersInvoker->getSubscribedSystems($class, Event::prePersist)) { $this->eventListenersInvoker->invoke($class, Event::prePersist, $document, new LifecycleEventArgs($document, $this->dm), $invoke); } $generator = $this->getIdGenerator($overrideIdGenerator ? $overrideIdGenerator : $class->idGenerator); $id = $generator->generate($document, $class, $this->dm, $parent); $this->registerDocument($document, $id); if (!$generator instanceof AssignedIdGenerator) { $class->setIdentifierValue($document, $id); } // If the UUID is mapped, generate it early resp. validate if already present. $uuidFieldName = $class->getUuidFieldName(); if ($uuidFieldName) { $existingUuid = $class->getFieldValue($document, $uuidFieldName); if (!$existingUuid) { $class->setFieldValue($document, $uuidFieldName, $this->generateUuid()); } elseif (!UUIDHelper::isUUID($existingUuid)) { throw RuntimeException::invalidUuid($id, ClassUtils::getClass($document), $existingUuid); } } }
/** * Load the document from the content repository in the given language. * If $fallback is set to true, then the language chooser strategy is used to load the best suited * language for the translatable fields. * * If no translations can be found either using the fallback mechanism or not, an error is thrown. * * Note that this will be the same object as you got with a previous find/findTranslation call - we can't * allow copies of objects to exist * * @param $className * @param $id * @param $locale The language to try to load * @param bool $fallback Set to true if the language fallback mechanism should be used * @return object */ public function findTranslation($className, $id, $locale, $fallback = true) { try { $node = UUIDHelper::isUUID($id) ? $this->session->getNodeByIdentifier($id) : $this->session->getNode($id); } catch (\PHPCR\PathNotFoundException $e) { return null; } $hints = array('locale' => $locale, 'fallback' => $fallback); return $this->unitOfWork->createDocument($className, $node, $hints); }