PHP NodeHelper::purgeWorkspace方法代码示例

    /**
     * {@inheritDoc}
     */
    protected function execute(InputInterface $input, OutputInterface $output)
    {
        $session = $this->getPhpcrSession();
        $force = $input->getOption('force');

        $workspaceName = $session->getWorkspace()->getName();
        if (!$force) {
            /** @var $dialog DialogHelper */
            $dialog = $this->getHelperSet()->get('dialog');
            $force = $dialog->askConfirmation($output, sprintf(
                '<question>Are you sure you want to purge workspace "%s" Y/N ?</question>',
                $workspaceName
            ), false);
        }

        if (!$force) {
            $output->writeln('<error>Aborted</error>');

            return 1;
        }

        $output->writeln(sprintf('<info>Purging workspace:</info> %s', $workspaceName));

        // Using the static NodeHelper is bad for testing as we cannot mock it.
        NodeHelper::purgeWorkspace($session);
        $session->save();

        return 0;
    }

 public function testPurge()
 {
     $systemNodeCount = count($this->session->getRootNode()->getNodes());
     $a = $this->session->getRootNode()->addNode('a', 'nt:unstructured');
     $a->addMixin('mix:referenceable');
     $b = $this->session->getRootNode()->addNode('b', 'nt:unstructured');
     $b->addMixin('mix:referenceable');
     $this->session->save();
     $a->setProperty('ref', $b, PropertyType::REFERENCE);
     $b->setProperty('ref', $a, PropertyType::REFERENCE);
     $this->session->save();
     NodeHelper::purgeWorkspace($this->session);
     if ($this->session->getWorkspace()->getName() == 'crx.default') {
         // if we would continue, we would delete all content from the only real workspace
         $this->markTestIncomplete('TODO: how to test this with crx where we have no workspaces?');
     }
     $this->session->save();
     // if there where system nodes, they should still be here
     $this->assertCount($systemNodeCount, $this->session->getRootNode()->getNodes());
 }

 protected function execute(InputInterface $input, OutputInterface $output)
 {
     /** @var SessionInterface $session */
     $session = $this->getContainer()->get('sulu.phpcr.session')->getSession();
     /** @var WorkspaceInterface $workspace */
     $workspace = $session->getWorkspace();
     // init node namespace and types
     $output->writeln('Register namespace');
     $workspace->getNamespaceRegistry()->registerNamespace('sulu', 'http://sulu.io/phpcr');
     $workspace->getNamespaceRegistry()->registerNamespace($this->getContainer()->getParameter('sulu.content.language.namespace'), 'http://sulu.io/phpcr/locale');
     $output->writeln('Register node types');
     foreach ([new SuluNodeType(), new PathNodeType(), new ContentNodeType(), new SnippetNodeType(), new PageNodeType(), new HomeNodeType()] as $nodeType) {
         $output->writeln('  - ' . $nodeType->getName());
         $workspace->getNodeTypeManager()->registerNodeType($nodeType, true);
     }
     /** @var SessionInterface $session */
     $session = $this->getContainer()->get('sulu.phpcr.session')->getSession();
     if ($input->getOption('clear')) {
         NodeHelper::purgeWorkspace($session);
         $session->save();
         $output->writeln('Clear repository');
     }
 }

 public function testDeleteMoreThanOneThousandNodes()
 {
     $nodes = array();
     $root = $this->session->getNode('/');
     $parent = $root->addNode('test-more-than-one-thousand');
     for ($i = 0; $i <= 1200; $i++) {
         $nodes[] = $parent->addNode('node-' . $i);
     }
     $this->session->save();
     NodeHelper::purgeWorkspace($this->session);
     $this->session->save();
 }

 /**
  * Helper method for importing to add a node with the proper uuid behavior
  *
  * @param \PHPCR\NodeInterface $parentNode   the node to add this node to
  * @param string               $nodename     the node name to use
  * @param string               $type         the primary type name to use
  * @param int                  $uuidBehavior one of the constants of ImportUUIDBehaviorInterface
  *
  * @return NodeInterface the created node
  *
  * @throws \PHPCR\ItemExistsException if IMPORT_UUID_COLLISION_THROW and
  *      duplicate id
  * @throws \PHPCR\NodeType\ConstraintViolationException if behavior is remove or
  *      replace and the node with the uuid is in the parent path.
  */
 private static function addNode(NodeInterface $parentNode, $nodename, $type, $properties, $uuidBehavior)
 {
     $forceReferenceable = false;
     if (isset($properties['jcr:uuid'])) {
         try {
             $existing = $parentNode->getSession()->getNodeByIdentifier($properties['jcr:uuid']['values']);
             switch ($uuidBehavior) {
                 case self::IMPORT_UUID_CREATE_NEW:
                     unset($properties['jcr:uuid']);
                     $forceReferenceable = true;
                     break;
                 case self::IMPORT_UUID_COLLISION_THROW:
                     throw new ItemExistsException('There already is a node with uuid ' . $properties['jcr:uuid']['values'] . ' in this workspace.');
                 case self::IMPORT_UUID_COLLISION_REMOVE_EXISTING:
                 case self::IMPORT_UUID_COLLISION_REPLACE_EXISTING:
                     if (self::IMPORT_UUID_COLLISION_REPLACE_EXISTING == $uuidBehavior && 'jcr:root' == $nodename && $existing->getDepth() == 0) {
                         break;
                     }
                     if (!strncmp($existing->getPath() . '/', $parentNode->getPath() . "/{$nodename}", strlen($existing->getPath() . '/'))) {
                         throw new ConstraintViolationException('Trying to remove/replace parent of the path we are adding to. ' . $existing->getIdentifier() . ' at ' . $existing->getPath());
                     }
                     if (self::IMPORT_UUID_COLLISION_REPLACE_EXISTING == $uuidBehavior) {
                         // replace the found node. spec is not precise: do we keep the name or use the one of existing?
                         $parentNode = $existing->getParent();
                     }
                     $existing->remove();
                     break;
                 default:
                     // @codeCoverageIgnoreStart
                     throw new RepositoryException("Unexpected type {$uuidBehavior}");
                     // @codeCoverageIgnoreEnd
             }
         } catch (\PHPCR\ItemNotFoundException $e) {
             // nothing to do, we can add the node without conflict
         }
     }
     /* we add a jcr:root somewhere in the tree (either create new ids or
      * the root was not referenceable. do not make jackrabbit think it
      * would be the real root node.
      */
     if ('jcr:root' === $nodename && 'rep:root' === $type) {
         $type = 'nt:unstructured';
     }
     if ('jcr:root' == $nodename && isset($existing) && $existing->getDepth() === 0 && self::IMPORT_UUID_COLLISION_REPLACE_EXISTING == $uuidBehavior) {
         // update the root node properties
         // http://www.day.com/specs/jcr/2.0/11_Import.html#11.9%20Importing%20%3CI%3Ejcr:root%3C/I%3E
         NodeHelper::purgeWorkspace($parentNode->getSession());
         $node = $existing;
     } else {
         $node = $parentNode->addNode($nodename, $type);
     }
     foreach ($properties as $name => $info) {
         if ('jcr:primaryType' == $name) {
             // handled in node constructor
         } elseif ('jcr:mixinTypes' == $name) {
             if (is_array($info['values'])) {
                 foreach ($info['values'] as $type) {
                     $node->addMixin($type);
                 }
             } else {
                 $node->addMixin($info['values']);
             }
         } elseif ('jcr:created' == $name || 'jcr:createdBy' == $name) {
             // skip PROTECTED properties. TODO: get the names from node type instead of hardcode
         } elseif ('jcr:uuid' == $name) {
             //avoid to throw an exception when trying to set a UUID when importing from XML
             $node->setProperty($name, $info['values'], $info['type'], false);
         } else {
             $node->setProperty($name, $info['values'], $info['type']);
         }
     }
     if ($forceReferenceable && !$node->isNodeType('mix:referenceable')) {
         $node->addMixin('mix:referenceable');
     }
     return $node;
 }

 /**
  * @Given /^I purge the current workspace$/
  */
 public function iPurgeTheCurrentWorkspace()
 {
     $session = $this->getSession();
     NodeHelper::purgeWorkspace($session);
 }

 /**
  * @inheritDoc
  */
 public function purge()
 {
     $session = $this->dm->getPhpcrSession();
     NodeHelper::purgeWorkspace($session);
     $session->save();
 }

 /**
  * Initialize / reset the Sulu PHPCR environment.
  *
  * NOTE: We could use the document initializer here rather than manually creating
  *       the webspace nodes, but it currently adds more overhead and offers
  *       no control over *which* webspaces are created, see
  *       https://github.com/sulu-io/sulu/pull/2063 for a solution.
  */
 protected function initPhpcr()
 {
     /** @var SessionInterface $session */
     $session = $this->getContainer()->get('sulu_document_manager.default_session');
     $liveSession = $this->getContainer()->get('sulu_document_manager.live_session');
     if ($session->nodeExists('/cmf')) {
         NodeHelper::purgeWorkspace($session);
         $session->save();
     }
     if ($liveSession->nodeExists('/cmf')) {
         NodeHelper::purgeWorkspace($liveSession);
         $liveSession->save();
     }
     if (!$this->importer) {
         $this->importer = new PHPCRImporter($session, $liveSession);
     }
     // initialize the content repository.  in order to speed things up, for
     // each process, we dump the initial state to an XML file and restore
     // it thereafter.
     $initializerDump = __DIR__ . '/../Resources/app/cache/initial.xml';
     $initializerDumpLive = __DIR__ . '/../Resources/app/cache/initial_live.xml';
     if (true === self::$workspaceInitialized) {
         $session->importXml('/', $initializerDump, ImportUUIDBehaviorInterface::IMPORT_UUID_COLLISION_THROW);
         $session->save();
         $liveSession->importXml('/', $initializerDumpLive, ImportUUIDBehaviorInterface::IMPORT_UUID_COLLISION_THROW);
         $liveSession->save();
         return;
     }
     $filesystem = new Filesystem();
     if (!$filesystem->exists(dirname($initializerDump))) {
         $filesystem->mkdir(dirname($initializerDump));
     }
     $this->getContainer()->get('sulu_document_manager.initializer')->initialize();
     $handle = fopen($initializerDump, 'w');
     $liveHandle = fopen($initializerDumpLive, 'w');
     $session->exportSystemView('/cmf', $handle, false, false);
     $liveSession->exportSystemView('/cmf', $liveHandle, false, false);
     fclose($handle);
     self::$workspaceInitialized = true;
 }

 /**
  * Purge the workspace.
  */
 public function purgeWorkspace()
 {
     NodeHelper::purgeWorkspace($this->session);
 }