Inheritance: extends Jarves\Model\Base\Node
 /**
  * Creates a Node object based on given $routeName or current route.
  *
  * @param string|null $routeName
  *
  * @return Node
  */
 public function createPageFromRoute($routeName = null)
 {
     if (!$routeName) {
         $routeName = $this->pageStack->getRequest()->attributes->get('_route');
         if (!$routeName) {
             throw new \RuntimeException('Could not detect route name');
         }
     }
     $reflection = new \ReflectionClass($this->router->getGenerator());
     $key = 'jarves_routes';
     $cache = $this->cacher->getFastCache($key);
     $validCache = false;
     $routes = [];
     if ($cache) {
         $validCache = $cache['time'] === filemtime($reflection->getFileName()) && isset($cache['routes']) && is_string($cache['routes']);
         if ($validCache) {
             $routes = unserialize($cache['routes']);
         }
     }
     if (!$validCache) {
         $routes = $this->router->getRouteCollection()->all();
         $this->cacher->setFastCache($key, ['time' => filemtime($reflection->getFileName()), 'routes' => serialize($routes)]);
     }
     if (!isset($routes[$routeName])) {
         throw new \RuntimeException("Route with name `{$routeName}` does not exist");
     }
     $route = $routes[$routeName];
     $url = $this->router->generate($routeName, $this->pageStack->getRequest()->attributes->all());
     $page = Node::createPage($route->getOption('title'), parse_url($url)['path'], $route->getOption('theme'), $route->getOption('layout'));
     if ($route->getOption('meta')) {
         foreach ((array) $route->getOption('meta') as $key => $value) {
             $page->meta->set($key, $value);
         }
     }
     return $page;
 }
Exemple #2
0
 /**
  * @static
  *
  * @param Node $pNode
  * @param array $pBoxedContents
  */
 function installContents(Node $pNode, $pBoxedContents)
 {
     if (!is_array($pBoxedContents)) {
         return;
     }
     /**
      * 0: type74
      * 1: title
      * 2: template
      * 3: content
      *
      */
     foreach ($pBoxedContents as $boxId => $contents) {
         foreach ($contents as $content) {
             $oContent = new Content();
             $oContent->setNodeId($pNode->getId());
             $oContent->setBoxId($boxId);
             $oContent->setType($content[0]);
             $oContent->setTemplate($content[2]);
             $oContent->setContent($content[3]);
             $oContent->save();
         }
     }
 }
Exemple #3
0
 /**
  * @return string
  */
 public function getLayout(Node $node)
 {
     if ($nodeId = (int) $this->pageStack->getRequest()->get('_jarves_editor_node')) {
         if ($this->editMode->isEditMode($nodeId)) {
             if ($layout = $this->pageStack->getRequest()->get('_jarves_editor_layout')) {
                 return $layout;
             }
         }
     }
     return $node->getLayout();
 }
 protected function exportNode($position, Domain $domain, Node $node, ExportPointer $exportPointer)
 {
     $data = $node->toArray(TableMap::TYPE_CAMELNAME);
     if (!$node->getUrn()) {
         return;
     }
     $path = $node->getUrn();
     $exportPointer->pushPath($path);
     if ($node->getId() === $domain->getStartnodeId()) {
         $domain->setVirtualColumn('startnodePath', $path);
     }
     $nodeData = $this->clearData($data, ['id', 'lft', 'rgt', 'lvl', 'pid', 'urn', 'domainId'], ['type' => 0, 'layout' => 'default', 'visible' => true]);
     $nodeData['sort'] = $position;
     $contents = $node->getContents();
     $contentsData = [];
     foreach ($contents as $content) {
         $contentData = $content->toArray(TableMap::TYPE_CAMELNAME);
         $jsonDecoded = json_decode($contentData['content'], true);
         if (JSON_ERROR_NONE === json_last_error()) {
             $contentData['content'] = $jsonDecoded;
         }
         $contentData = $this->clearData($contentData, ['id', 'nodeId'], ['template' => 'JarvesBundle:Default:content.html.twig', 'type' => 'text']);
         $contentsData[] = $contentData;
     }
     $nodeData['contents'] = $contentsData;
     $exportPointer->addData($nodeData, '.yml');
     foreach ($node->getChildren() as $idx => $child) {
         $this->exportNode($idx, $domain, $child, $exportPointer);
     }
     $exportPointer->popPath();
 }
Exemple #5
0
 public function testNestedSubPermission()
 {
     $this->getACL()->setCaching(false);
     $this->getACL()->removeObjectRules('jarves/node');
     $tokenStorage = $this->getTokenStorage();
     $token = new UsernamePasswordToken(UserQuery::create()->findOneByUsername('test'), null, "main");
     $tokenStorage->setToken($token);
     $user = $this->getPageStack()->getUser();
     $this->assertEquals('test', $user->getUsername());
     $domain = DomainQuery::create()->findOne();
     $root = NodeQuery::create()->findRoot($domain->getId());
     $subNode = new Node();
     $subNode->setTitle('TestNode tree');
     $subNode->insertAsFirstChildOf($root);
     $subNode->save();
     $subNode2 = new Node();
     $subNode2->setTitle('TestNode sub');
     $subNode2->insertAsFirstChildOf($subNode);
     $subNode2->save();
     //make access for all
     $rule = new Acl();
     $rule->setAccess(true);
     $rule->setObject('jarves/node');
     $rule->setTargetType(\Jarves\ACL::TARGET_TYPE_USER);
     $rule->setTargetId($user->getId());
     $rule->setMode(\Jarves\ACL::MODE_ALL);
     $rule->setConstraintType(\Jarves\ACL::CONSTRAINT_ALL);
     $rule->setPrio(2);
     $rule->save();
     //revoke access for all children of `TestNode tree`
     $rule2 = new Acl();
     $rule2->setAccess(false);
     $rule2->setObject('jarves/node');
     $rule2->setTargetType(\Jarves\ACL::TARGET_TYPE_USER);
     $rule2->setTargetId($user->getId());
     $rule2->setMode(\Jarves\ACL::MODE_ALL);
     $rule2->setConstraintType(\Jarves\ACL::CONSTRAINT_CONDITION);
     $rule2->setConstraintCode(json_encode(['title', '=', 'TestNode tree']));
     $rule2->setPrio(3);
     $rule2->setSub(true);
     $rule2->save();
     $this->getCacher()->invalidateCache('core');
     $node1RequestListing = ACLRequest::create('jarves/node', $subNode->getId())->onlyListingMode();
     $node2RequestListing = ACLRequest::create('jarves/node', $subNode2->getId())->onlyListingMode();
     $this->assertFalse($this->getACL()->check($node1RequestListing));
     $this->assertFalse($this->getACL()->check($node2RequestListing));
     $items = $this->getObjects()->getBranch('jarves/node', $subNode->getId(), null, 1, null, ['permissionCheck' => true]);
     $this->assertNull($items, 'rule2 revokes the access to all elements');
     $item = $this->getObjects()->get('jarves/node', $subNode2->getId(), ['permissionCheck' => true]);
     $this->assertNull($item);
     // Deactivate sub
     $rule2->setSub(false);
     $rule2->save();
     $this->assertFalse($this->getACL()->check($node1RequestListing));
     $this->assertTrue($this->getACL()->check($node2RequestListing));
     $items = $this->getObjects()->getBranch('jarves/node', $subNode->getId(), null, 1, null, ['permissionCheck' => true]);
     $this->assertEquals('TestNode sub', $items[0]['title'], 'We got TestNode sub');
     $item = $this->getObjects()->get('jarves/node', $subNode2->getId(), ['permissionCheck' => true]);
     $this->assertEquals('TestNode sub', $item['title'], 'We got TestNode sub');
     // Activate access
     $rule2->setAccess(true);
     $rule2->save();
     $this->assertTrue($this->getACL()->check($node1RequestListing));
     $this->assertTrue($this->getACL()->check($node2RequestListing));
     $items = $this->getObjects()->getBranch('jarves/node', $subNode->getId(), null, 1, null, ['permissionCheck' => true]);
     $this->assertEquals('TestNode sub', $items[0]['title'], 'We got TestNode sub');
     $subNode->delete();
     $subNode2->delete();
     $rule->delete();
     $rule2->delete();
     $this->getACL()->setCaching(true);
 }
Exemple #6
0
 public function registerPluginRoutes(Node $page)
 {
     $domain = $this->pageStack->getDomain($page->getDomainId());
     $this->stopwatch->start('Register Plugin Routes');
     //add all router to current router and fire sub-request
     $cacheKey = 'core/node/plugins-' . $page->getId();
     $plugins = $this->cacher->getDistributedCache($cacheKey);
     if (null === $plugins) {
         $plugins = ContentQuery::create()->filterByNodeId($page->getId())->filterByType('plugin')->find();
         $this->cacher->setDistributedCache($cacheKey, serialize($plugins));
     } else {
         $plugins = unserialize($plugins);
     }
     /** @var $plugins Content[] */
     foreach ($plugins as $plugin) {
         if (!$plugin->getContent()) {
             continue;
         }
         $data = json_decode($plugin->getContent(), true);
         if (!$data) {
             $this->logger->alert(sprintf('On page `%s` [%d] is a invalid plugin `%d`.', $page->getTitle(), $page->getId(), $plugin->getId()));
             continue;
         }
         $bundleName = isset($data['module']) ? $data['module'] : @$data['bundle'];
         $config = $this->jarves->getConfig($bundleName);
         if (!$config) {
             $this->logger->alert(sprintf('Bundle `%s` for plugin `%s` on page `%s` [%d] does not not exist.', $bundleName, @$data['plugin'], $page->getTitle(), $page->getId()));
             continue;
         }
         $pluginDefinition = $config->getPlugin(@$data['plugin']);
         if (!$pluginDefinition) {
             $this->logger->alert(sprintf('In bundle `%s` the plugin `%s` on page `%s` [%d] does not not exist.', $bundleName, @$data['plugin'], $page->getTitle(), $page->getId()));
             continue;
         }
         if ($pluginRoutes = $pluginDefinition->getRoutes()) {
             foreach ($pluginRoutes as $idx => $route) {
                 $controller = $pluginDefinition->getController();
                 $defaults = array('_controller' => $route->getController() ?: $controller, '_jarves_is_plugin' => true, '_content' => $plugin, '_title' => sprintf('%s: %s', $bundleName, $pluginDefinition->getLabel()), 'options' => isset($data['options']) && is_array($data['options']) ? $data['options'] : [], 'jarvesFrontend' => true, 'nodeId' => $page->getId());
                 if ($route->getDefaults()) {
                     $defaults = array_merge($defaults, $route->getArrayDefaults());
                 }
                 $url = $this->pageStack->getRouteUrl($page->getId());
                 $this->routes->add('jarves_frontend_plugin_' . ($route->getId() ?: $plugin->getId()) . '_' . $idx, new SyRoute($url . '/' . $route->getPattern(), $defaults, $route->getArrayRequirements() ?: array(), [], '', [], $route->getMethods() ?: []));
             }
         }
     }
     $this->stopwatch->stop('Register Plugin Routes');
 }
 protected function import(InputInterface $input, OutputInterface $output)
 {
     $basePath = 'app/jarves/';
     $openedFiles = [];
     $domains = [];
     $nodes = [];
     $rootNodes = [];
     $ymlParser = new Parser();
     Propel::getWriteConnection('default')->beginTransaction();
     //import files
     $fileReferencesPath = $basePath . '/file_references.yml';
     if (file_exists($fileReferencesPath)) {
         $openedFiles[$fileReferencesPath] = filemtime($fileReferencesPath);
         $fileReferences = $ymlParser->parse(file_get_contents($fileReferencesPath));
         $output->writeln(sprintf('Import %d file references ...', count($fileReferences)));
         FileQuery::create()->deleteAll();
         foreach ($fileReferences as $id => $path) {
             $file = new File();
             $file->setId($id);
             $file->setPath($path);
             $file->save();
         }
     }
     $relativePathBase = $basePath . 'website/';
     $dir = opendir($relativePathBase);
     while ($domainName = readdir($dir)) {
         if ('.' === $domainName || '..' === $domainName || '.yml' === substr($domainName, -4)) {
             continue;
         }
         $files = new \RecursiveIteratorIterator(new \RecursiveDirectoryIterator($basePath . 'website/' . $domainName));
         $files = iterator_to_array($files);
         ksort($files);
         $output->writeln(sprintf('Import domain %s ...', $domainName));
         $domain = DomainQuery::create()->findOneByDomain($domainName);
         if (!$domain) {
             $domain = new Domain();
         }
         $ymlPath = $relativePathBase . $domainName . '.yml';
         $domainFromYml = $ymlParser->parse(file_get_contents($ymlPath));
         $openedFiles[$ymlPath] = filemtime($ymlPath);
         $oldData = $domain->toArray(TableMap::TYPE_CAMELNAME);
         $domain->fromArray(array_merge($oldData, $domainFromYml), TableMap::TYPE_CAMELNAME);
         $domain->setStartnodeId(null);
         if (isset($domainFromYml['startnode'])) {
             $domain->setVirtualColumn('startnodePath', $domainFromYml['startnode']);
         }
         $domain->save();
         $domains[$domainName] = $domain;
         NodeQuery::create()->filterByDomain($domain)->delete();
         $rootNode = new Node();
         $rootNode->setTitle('root');
         $rootNode->makeRoot();
         $rootNode->setDomain($domain);
         $rootNode->save();
         $rootNodes[$domainName] = $rootNode;
         $nodes[''] = $rootNode;
         $parentNodeQueue = [];
         /** @var \SplFileInfo $file */
         foreach ($files as $file) {
             if ('.' === $file->getFilename() || '..' === $file->getFilename() || '.yml' !== substr($file->getFilename(), -4)) {
                 continue;
             }
             $path = $file->getPath() . '/' . $file->getFilename();
             $path = substr($path, strlen($relativePathBase . $domainName) + 1);
             if (!$path) {
                 continue;
             }
             $parentPath = '';
             if (false !== strpos($path, '/')) {
                 $parentPath = dirname($path);
             }
             $baseName = substr(basename($path), 0, -4);
             //without .yml
             if ($baseName) {
                 //its a node
                 $node = isset($nodes[$path]) ? $nodes[$path] : new Node();
                 $ymlPath = $relativePathBase . $domainName . '/' . $path;
                 $nodeFromYml = $ymlParser->parse(file_get_contents($ymlPath));
                 $openedFiles[$ymlPath] = filemtime($ymlPath);
                 $node->fromArray($nodeFromYml, TableMap::TYPE_CAMELNAME);
                 $node->setDomain($domain);
                 $urn = $baseName;
                 if (false !== ($dotPos = strpos($baseName, '.'))) {
                     $prefix = substr($baseName, 0, $dotPos);
                     if ($prefix) {
                         $urn = substr($baseName, $dotPos + 1);
                     }
                 }
                 $node->setUrn($urn);
                 $output->writeln(sprintf('Import page %s%s ...', str_repeat('  ', substr_count($path, '/')), $node->getTitle()));
                 $nodes[substr($path, 0, -4)] = $node;
                 $end = isset($parentNodeQueue[$parentPath]) ? count($parentNodeQueue[$parentPath]) : 1;
                 $position = isset($nodeFromYml['sort']) ? $nodeFromYml['sort'] : $end;
                 $parentNodeQueue[$parentPath][$position][] = $node;
                 if (isset($nodeFromYml['contents'])) {
                     foreach ($nodeFromYml['contents'] as $idx => $contentFromYaml) {
                         if (isset($contentFromYaml['content']) && is_array($contentFromYaml['content'])) {
                             $contentFromYaml['content'] = json_encode($contentFromYaml['content']);
                         }
                         $content = new Content();
                         $content->setSort($idx);
                         $content->fromArray($contentFromYaml, TableMap::TYPE_CAMELNAME);
                         $content->setNode($node);
                     }
                     if ($domain->hasVirtualColumn('startnodePath') && substr($path, 0, -4) === $domain->getVirtualColumn('startnodePath')) {
                         $domain->setStartnode($node);
                     }
                 }
             }
         }
         //save queued nodes
         foreach ($parentNodeQueue as $parentPath => $nodesQueue) {
             ksort($nodesQueue);
             //key is sort
             /** @var Node $node */
             foreach ($nodesQueue as $position => $nodesToInsert) {
                 foreach ($nodesToInsert as $node) {
                     $node->insertAsLastChildOf($nodes[$parentPath]);
                     $node->save();
                     //saves Content as well.
                 }
             }
         }
         $domain->save();
     }
     Propel::getWriteConnection('default')->commit();
     $cacher = $this->getContainer()->get('jarves.cache.cacher');
     $cacher->invalidateCache('core');
     return $openedFiles;
 }