private List<RepositoryFile> legacyGetDeletedFiles(
     final Session session,
     final PentahoJcrConstants pentahoJcrConstants,
     final String origParentFolderPath,
     final String filter)
     throws RepositoryException {
   List<RepositoryFile> deletedFiles = new ArrayList<RepositoryFile>();
   Node trashFolderIdNode =
       legacyGetTrashFolderIdNode(session, pentahoJcrConstants, origParentFolderPath);
   if (trashFolderIdNode == null) {
     return Collections.emptyList();
   }
   NodeIterator nodes = trashFolderIdNode.getNodes();
   while (nodes.hasNext()) {
     Node trashFileIdNode = nodes.nextNode();
     NodeIterator trashFileIdNodes = null;
     if (filter != null) {
       trashFileIdNodes = trashFileIdNode.getNodes(filter);
     } else {
       trashFileIdNodes = trashFileIdNode.getNodes();
     }
     if (trashFileIdNodes.hasNext()) {
       deletedFiles.add(
           nodeToDeletedFile(session, pentahoJcrConstants, trashFileIdNodes.nextNode()));
     }
   }
   return deletedFiles;
 }
  public void testRestoreSNS() throws RepositoryException {
    Session session = getHelper().getSuperuserSession();

    // - Create a node 'a' with nodetype nt:unstructured
    // (defining it's childnodes to show OPV Version behaviour)
    Node node = session.getRootNode().addNode("RestoreSameNameSiblingTest");
    try {
      // - Create a child node 'b'
      node.addNode("test");
      // - Make 'a' versionable (add mixin mix:versionable)
      node.addMixin(mixVersionable);
      session.save();

      // - Checkin/Checkout 'a'
      Version version = node.checkin();
      node.checkout();
      assertEquals(1, node.getNodes("test").getSize());

      // - Restore any version of 'a'
      node.restore(version, true);
      assertEquals(1, node.getNodes("test").getSize());
    } finally {
      node.remove();
      session.save();
      session.logout();
    }
  }
Example #3
0
  @Test
  @FixFor("MODE-1489")
  public void shouldAllowMultipleOrderBeforeWithoutSave() throws Exception {
    int childCount = 2;

    Node parent = session.getRootNode().addNode("parent", "nt:unstructured");
    for (int i = 0; i < childCount; i++) {
      parent.addNode("Child " + i, "nt:unstructured");
    }

    session.save();

    long childIdx = 0;
    NodeIterator nodeIterator = parent.getNodes();
    while (nodeIterator.hasNext()) {
      parent.orderBefore("Child " + childIdx, "Child 0");
      childIdx++;
      nodeIterator.nextNode();
    }

    session.save();

    nodeIterator = parent.getNodes();
    childIdx = nodeIterator.getSize() - 1;
    while (nodeIterator.hasNext()) {
      Node child = nodeIterator.nextNode();
      assertEquals("Child " + childIdx, child.getName());
      childIdx--;
    }
  }
Example #4
0
  @Test
  public void shouldCreateProjectionWithAlias() throws Exception {
    // add an internal node
    testRoot.addNode("node1");
    session.save();

    // link the first external document
    federationManager.createProjection(
        "/testRoot", SOURCE_NAME, MockConnector.DOC1_LOCATION, "federated1");
    assertEquals(2, testRoot.getNodes().getSize());

    Node doc1Federated = assertNodeFound("/testRoot/federated1");
    assertEquals(testRoot.getIdentifier(), doc1Federated.getParent().getIdentifier());
    assertEquals("a string", doc1Federated.getProperty("federated1_prop1").getString());
    assertEquals(12, doc1Federated.getProperty("federated1_prop2").getLong());

    // link a second external document with a sub-child
    federationManager.createProjection(
        "/testRoot", SOURCE_NAME, MockConnector.DOC2_LOCATION, "federated2");
    assertEquals(3, testRoot.getNodes().getSize());

    Node doc2Federated = assertNodeFound("/testRoot/federated2");
    assertEquals(testRoot.getIdentifier(), doc2Federated.getParent().getIdentifier());
    assertEquals("another string", doc2Federated.getProperty("federated2_prop1").getString());
    assertEquals(false, doc2Federated.getProperty("federated2_prop2").getBoolean());

    Node doc2FederatedChild = assertNodeFound("/testRoot/federated2/federated3");
    assertEquals(
        "yet another string", doc2FederatedChild.getProperty("federated3_prop1").getString());
  }
  /** {@inheritDoc} */
  public List<RepositoryFile> getDeletedFiles(
      final Session session, final PentahoJcrConstants pentahoJcrConstants)
      throws RepositoryException {
    Node trashNode = getOrCreateTrashInternalFolderNode(session, pentahoJcrConstants);

    if (trashNode == null) {
      return Collections.emptyList();
    }

    List<RepositoryFile> deletedFiles = new ArrayList<RepositoryFile>();

    NodeIterator nodes = trashNode.getNodes();
    while (nodes.hasNext()) {
      Node trashFileNode = nodes.nextNode();

      // since the nodes returned are the trash file ID nodes,
      // we need to getNodes().nextNode() to get its first (and only) child

      if (trashFileNode != null
          && trashFileNode.hasProperty(pentahoJcrConstants.getPHO_DELETEDDATE())) {

        NodeIterator trashFileNodeIterator = trashFileNode.getNodes();

        if (trashFileNodeIterator.hasNext()) {
          deletedFiles.add(
              nodeToDeletedFile(session, pentahoJcrConstants, trashFileNodeIterator.nextNode()));
        }
      }
    }
    Collections.sort(deletedFiles);
    return deletedFiles;
  }
 private void nextTopNode() throws RepositoryException {
   topNode = nextDirNode(topIterator);
   if (topNode != null) {
     midIterator = topNode.getNodes();
     midNode = nextDirNode(midIterator);
     if (midNode != null) {
       bottomIterator = midNode.getNodes();
     }
   }
 }
Example #7
0
 /**
  * see https://issues.jboss.org/browse/MODE-1953
  *
  * @throws Exception
  */
 @Test
 public void testGetNodesMethod() throws Exception {
   Node jcrRootNode = ((Session) session).getRootNode();
   Node rootNode = jcrRootNode.addNode("mapSuperclassTest");
   Node newNode = rootNode.addNode("newNode");
   NodeIterator nodeIterator = rootNode.getNodes("myMap");
   assertFalse(nodeIterator.hasNext());
   session.save();
   nodeIterator = rootNode.getNodes("myMap");
   assertFalse(nodeIterator.hasNext());
 }
Example #8
0
 @Test
 public void shouldReturnEmptyIterator() throws RepositoryException {
   Node jcrRootNode = session.getRootNode();
   Node rootNode = jcrRootNode.addNode("mapSuperclassTest");
   // session.save();
   Node newNode = rootNode.addNode("newNode");
   assertNotNull(newNode);
   NodeIterator nodeIterator = rootNode.getNodes("myMap");
   assertFalse(nodeIterator.hasNext());
   session.save();
   nodeIterator = rootNode.getNodes("myMap");
   assertFalse(nodeIterator.hasNext());
 }
Example #9
0
 /**
  * Get node nt:file if node support multi-language
  *
  * @param currentNode Current Node
  * @return Node which has type nt:file
  * @throws Exception
  */
 public static Node getFileLangNode(Node currentNode) throws Exception {
   if (currentNode.isNodeType(NT_UNSTRUCTURED)) {
     if (currentNode.getNodes().getSize() > 0) {
       NodeIterator nodeIter = currentNode.getNodes();
       while (nodeIter.hasNext()) {
         Node ntFile = nodeIter.nextNode();
         if (ntFile.getPrimaryNodeType().getName().equals(NT_FILE)) {
           return ntFile;
         }
       }
       return currentNode;
     }
   }
   return currentNode;
 }
Example #10
0
 protected void activate(final ComponentContext ctx) {
   if (TMP_DIR != null) {
     File tmpDir = new File(TMP_DIR);
     fontsDir = new File(tmpDir, "fonts." + UUID.randomUUID());
     fontsDir.mkdir();
     fontsDir.deleteOnExit();
     Session session = null;
     try {
       session = repo.loginAdministrative(repo.getDefaultWorkspace());
       if (session.nodeExists(FONT_CONFIG)) {
         configFile = createFile(session.getNode(FONT_CONFIG));
       }
       if (session.nodeExists(FONT_CONFIG_FONTS)) {
         Node fonts = session.getNode(FONT_CONFIG_FONTS);
         NodeIterator children = fonts.getNodes();
         while (children.hasNext()) {
           createFile((Node) children.next());
         }
       }
     } catch (RepositoryException e) {
       logger.error("Failed exporting FOP font data.", e);
     } finally {
       if (session != null) {
         session.logout();
       }
     }
   }
 }
 private static void traverseNodes(Node node, int currentLevel) throws Exception {
   System.out.println(node.getPath());
   NodeIterator children = node.getNodes();
   while (children.hasNext()) {
     traverseNodes(children.nextNode(), currentLevel + 1);
   }
 }
  /** Recursively outputs the contents of the given node. */
  private static void dump(Node node) throws RepositoryException {
    // First output the node path
    System.out.println(node.getPath());
    // Skip the virtual (and large!) jcr:system subtree
    if (node.getName().equals("jcr:system")) {
      return;
    }

    // Then output the properties
    PropertyIterator properties = node.getProperties();
    while (properties.hasNext()) {
      Property property = properties.nextProperty();
      if (property.getDefinition().isMultiple()) {
        // A multi-valued property, print all values
        Value[] values = property.getValues();
        for (int i = 0; i < values.length; i++) {
          System.out.println(property.getPath() + " = " + values[i].getString());
        }
      } else {
        // A single-valued property
        System.out.println(property.getPath() + " = " + property.getString());
      }
    }

    // Finally output all the child nodes recursively
    NodeIterator nodes = node.getNodes();
    while (nodes.hasNext()) {
      dump(nodes.nextNode());
    }
  }
  private void checkCustomProperties(Session session) throws javax.jcr.RepositoryException {

    NodeTypeManager nodetypeManager = new NodeTypeManager();
    // Check and create required custom properties
    javax.jcr.Node systemNode = JCRUtils.getSystemNode(session);
    if (systemNode.hasNode(JLibraryConstants.JLIBRARY_CUSTOM_PROPERTIES)) {
      javax.jcr.Node propertiesNode =
          systemNode.getNode(JLibraryConstants.JLIBRARY_CUSTOM_PROPERTIES);
      NodeIterator it = propertiesNode.getNodes();
      while (it.hasNext()) {
        javax.jcr.Node propsNode = (javax.jcr.Node) it.next();
        CustomPropertyDefinition propdef = new CustomPropertyDefinition();
        propdef.setName(
            propsNode.getProperty(JLibraryConstants.JLIBRARY_PROPERTY_NAME).getString());
        propdef.setType(
            (int) propsNode.getProperty(JLibraryConstants.JLIBRARY_PROPERTY_TYPE).getLong());
        propdef.setMultivalued(
            propsNode.getProperty(JLibraryConstants.JLIBRARY_PROPERTY_MULTIVALUED).getBoolean());
        propdef.setAutocreated(
            propsNode.getProperty(JLibraryConstants.JLIBRARY_PROPERTY_AUTOCREATED).getBoolean());
        if (propsNode.hasProperty(JLibraryConstants.JLIBRARY_PROPERTY_DEFAULT)) {
          propdef.setDefaultValues(
              propsNode.getProperty(JLibraryConstants.JLIBRARY_PROPERTY_DEFAULT).getValues());
        }

        logger.info("Registering property : " + propdef);
        nodetypeManager.registerCustomProperty(session, propdef);
      }
    }
  }
  public void execute(WorkItem item, WorkflowSession session, MetaDataMap args)
      throws WorkflowException {
    WorkflowData workflowData = item.getWorkflowData();
    log.info("==================== <> ======================");
    Iterator props = args.entrySet().iterator();
    String pathToArchive = args.get("PROCESS_ARGS", String.class);
    if (pathToArchive != null)
      if (workflowData.getPayloadType().equals(TYPE_JCR_PATH)) {
        String path = workflowData.getPayload().toString();
        try {
          Node node = (Node) session.getSession().getItem(path + "/jcr:content");

          String orderBy = node.getProperty("orderby").getString();
          log.info("----------orderby: " + orderBy);
          Node nodeToOrder = (Node) session.getSession().getItem(pathToArchive);
          Iterator<Node> iterator = nodeToOrder.getNodes();
          List<Node> nodes = copyIterator(iterator);

          Collections.sort(nodes, new NodeComparator(orderBy));

          for (Node orderNode : nodes) {
            session
                .getSession()
                .getWorkspace()
                .move(
                    pathToArchive + "/" + orderNode.getName(),
                    pathToArchive + "/" + orderNode.getName());
          }

        } catch (RepositoryException e) {
          throw new WorkflowException(e.getMessage(), e);
        }
      }
  }
  @Test
  public void ferrari_has_four_wheels() throws RepositoryException {
    Node ferrari = session.getNode("/cars/ferrari");
    NodeIterator nodeIterator = ferrari.getNodes("catalog:wheel");

    assertThat(nodeIterator.getSize(), is(4L));
  }
  @Test
  public void ferrari_has_two_doors() throws RepositoryException {
    Node ferrari = session.getNode("/cars/ferrari");
    NodeIterator nodeIterator = ferrari.getNodes("catalog:door");

    assertThat(nodeIterator.getSize(), is(2L));
  }
Example #17
0
 public static NodeIterator getAuthorizedChildNodes(Node node) throws Exception {
   NodeIterator iter = node.getNodes();
   while (iter.hasNext()) {
     if (!PermissionUtil.canRead(iter.nextNode())) iter.remove();
   }
   return iter;
 }
Example #18
0
  public String[] getFileNames(long companyId, long repositoryId) throws SystemException {

    List<String> fileNames = new ArrayList<String>();

    Session session = null;

    try {
      session = JCRFactoryUtil.createSession();

      Node rootNode = getRootNode(session, companyId);

      Node repositoryNode = getFolderNode(rootNode, repositoryId);

      NodeIterator itr = repositoryNode.getNodes();

      while (itr.hasNext()) {
        Node node = (Node) itr.next();

        NodeType primaryNodeType = node.getPrimaryNodeType();

        String primaryNodeTypeName = primaryNodeType.getName();

        if (primaryNodeTypeName.equals(JCRConstants.NT_FILE)) {
          fileNames.add(node.getName());
        }
      }
    } catch (Exception e) {
      throw new SystemException(e);
    } finally {
      JCRFactoryUtil.closeSession(session);
    }

    return fileNames.toArray(new String[0]);
  }
  private void purgeHistory(Node fileNode, Session session, PentahoJcrConstants pentahoJcrConstants)
      throws RepositoryException {
    // Delete all previous versions of this node
    VersionManager versionManager = session.getWorkspace().getVersionManager();
    if (JcrRepositoryFileUtils.isPentahoFolder(pentahoJcrConstants, fileNode)) {
      // go down to children
      NodeIterator nodes = fileNode.getNodes();
      while (nodes.hasNext()) {
        Node next = (Node) nodes.next();
        purgeHistory(next, session, pentahoJcrConstants);
      }
    } else if (JcrRepositoryFileUtils.isPentahoFile(pentahoJcrConstants, fileNode)
        && fileNode.isNodeType(pentahoJcrConstants.getPHO_MIX_VERSIONABLE())) {
      VersionHistory versionHistory = versionManager.getVersionHistory(fileNode.getPath());

      VersionIterator allVersions = versionHistory.getAllVersions();
      while (allVersions.hasNext()) {
        Version next = (Version) allVersions.next();
        String name = next.getName();
        // Root version cannot be deleted, the remove below will take care of that.
        if (!JCR_ROOT_VERSION.equals(name)) {
          versionHistory.removeVersion(name);
        }
      }
    }
  }
Example #20
0
  @Override
  public List<JcrNode> childNodes(String path) throws RemoteException {
    List<JcrNode> children = null;
    if (path == null || path.trim().length() == 0) {
      return Collections.emptyList();
    }
    try {
      Node node = (Node) session().getItem(path);
      NodeIterator it = node.getNodes();
      children = new ArrayList<JcrNode>((int) it.getSize());

      while (it.hasNext()) {
        Node n = it.nextNode();
        JcrNode childNode = new JcrNode(n.getName(), n.getPath(), n.getPrimaryNodeType().getName());
        childNode.setProperties(getProperties(n));
        childNode.setAcessControlList(getAccessList(session().getAccessControlManager(), node));
        childNode.setMixins(mixins(n));
        childNode.setPropertyDefs(propertyDefs(n));
        children.add(childNode);
      }

    } catch (PathNotFoundException e) {
      log.log(Level.FINER, e.getLocalizedMessage());
    } catch (RepositoryException e) {
      log.log(Level.SEVERE, "Unexpected error", e);
      throw new RemoteException(e.getMessage());
    }

    return children;
  }
 /**
  * {@inheritDoc}
  *
  * @see
  *     org.modeshape.graph.request.processor.RequestProcessor#process(org.modeshape.graph.request.ReadAllPropertiesRequest)
  */
 @Override
 public void process(ReadAllPropertiesRequest request) {
   if (request == null) return;
   try {
     Workspace workspace = workspaceFor(request.inWorkspace());
     Node node = workspace.node(request.at());
     Location actualLocation = workspace.locationFor(node);
     request.setActualLocationOfNode(actualLocation);
     // Read the properties ...
     for (PropertyIterator iter = node.getProperties(); iter.hasNext(); ) {
       request.addProperty(workspace.propertyFor(iter.nextProperty()));
     }
     // Add in the 'jcr:uuid' property ...
     if (actualLocation.hasIdProperties()) {
       request.addProperty(workspace.propertyFor(ModeShapeLexicon.UUID, actualLocation.getUuid()));
     }
     // Get the number of children ...
     NodeIterator childIter = node.getNodes();
     int numChildren = (int) childIter.getSize();
     if (numChildren == -1) {
       numChildren = 0;
       while (childIter.hasNext()) {
         childIter.nextNode();
         ++numChildren;
       }
     }
     request.setNumberOfChildren(numChildren);
     setCacheableInfo(request);
   } catch (Throwable e) {
     request.setError(e);
   }
 }
 /**
  * {@inheritDoc}
  *
  * @see
  *     org.modeshape.graph.request.processor.RequestProcessor#process(org.modeshape.graph.request.ReadNodeRequest)
  */
 @Override
 public void process(ReadNodeRequest request) {
   if (request == null) return;
   try {
     Workspace workspace = workspaceFor(request.inWorkspace());
     Node node = workspace.node(request.at());
     Location actualLocation = workspace.locationFor(node);
     request.setActualLocationOfNode(actualLocation);
     // Read the children ...
     for (NodeIterator iter = node.getNodes(); iter.hasNext(); ) {
       request.addChild(workspace.locationFor(iter.nextNode()));
     }
     // Read the properties ...
     for (PropertyIterator iter = node.getProperties(); iter.hasNext(); ) {
       request.addProperty(workspace.propertyFor(iter.nextProperty()));
     }
     // Add in the 'jcr:uuid' property ...
     if (actualLocation.hasIdProperties()) {
       request.addProperty(workspace.propertyFor(ModeShapeLexicon.UUID, actualLocation.getUuid()));
     }
     setCacheableInfo(request);
   } catch (Throwable e) {
     request.setError(e);
   }
 }
Example #23
0
  /** Dump given node in JSON, optionally recursing into its child nodes */
  protected void dump(Node node, JSONWriter w, int currentRecursionLevel, int maxRecursionLevels)
      throws RepositoryException, JSONException {

    w.object();
    PropertyIterator props = node.getProperties();

    // the node's actual properties
    while (props.hasNext()) {
      Property prop = props.nextProperty();

      if (propertyNamesToIgnore != null && propertyNamesToIgnore.contains(prop.getName())) {
        continue;
      }

      writeProperty(w, prop);
    }

    // the child nodes
    if (recursionLevelActive(currentRecursionLevel, maxRecursionLevels)) {
      final NodeIterator children = node.getNodes();
      while (children.hasNext()) {
        final Node n = children.nextNode();
        dumpSingleNode(n, w, currentRecursionLevel, maxRecursionLevels);
      }
    }

    w.endObject();
  }
 private void listChildren(String indent, Node node, PrintStream out) throws RepositoryException {
   out.println(indent + node.getName() + "");
   out.println(node.getPath());
   NodeIterator ni = node.getNodes();
   while (ni.hasNext()) {
     listChildren(indent + "  ", ni.nextNode(), out);
   }
 }
Example #25
0
 /* (non-Javadoc)
  * @see junit.framework.TestCase#tearDown()
  */
 public void tearDown() throws Exception {
   super.tearDown();
   Node sharedPortalNode = (Node) session.getItem("/sites content/live/shared/js");
   NodeIterator nodeIterator = documentNode.getNodes();
   NodeIterator sharedNode = sharedJsNode.getNodes();
   NodeIterator sharedIterator = sharedPortalNode.getNodes();
   while (nodeIterator.hasNext()) {
     nodeIterator.nextNode().remove();
   }
   while (sharedNode.hasNext()) {
     sharedNode.nextNode().remove();
   }
   while (sharedIterator.hasNext()) {
     sharedIterator.nextNode().remove();
   }
   session.save();
 }
  public void setRoleBindings(
      Session session, ITenant tenant, String runtimeRoleName, List<String> logicalRoleNames)
      throws NamespaceException, RepositoryException {
    if (tenant == null) {
      tenant = JcrTenantUtils.getTenant(runtimeRoleName, false);
      runtimeRoleName = getPrincipalName(runtimeRoleName);
    }

    if (!TenantUtils.isAccessibleTenant(tenant)) {
      throw new NotFoundException("Tenant " + tenant.getId() + " not found");
    }

    PentahoJcrConstants pentahoJcrConstants = new PentahoJcrConstants(session);
    final String phoNsPrefix =
        session.getNamespacePrefix(PentahoJcrConstants.PHO_NS) + ":"; // $NON-NLS-1$
    final String onlyPentahoPattern = phoNsPrefix + "*"; // $NON-NLS-1$
    Node runtimeRolesFolderNode = getRuntimeRolesFolderNode(session, tenant);
    NodeIterator runtimeRoleNodes = runtimeRolesFolderNode.getNodes(onlyPentahoPattern);
    int i = 0;
    while (runtimeRoleNodes.hasNext()) {
      runtimeRoleNodes.nextNode();
      i++;
    }
    if (i == 0) {
      // no bindings setup yet; install bootstrap bindings; bootstrapRoleBindings will now no longer
      // be
      // consulted
      for (Map.Entry<String, List<String>> entry : bootstrapRoleBindings.entrySet()) {
        JcrRoleAuthorizationPolicyUtils.internalSetBindings(
            pentahoJcrConstants,
            runtimeRolesFolderNode,
            entry.getKey(),
            entry.getValue(),
            phoNsPrefix);
      }
    }
    if (!isImmutable(runtimeRoleName)) {
      JcrRoleAuthorizationPolicyUtils.internalSetBindings(
          pentahoJcrConstants,
          runtimeRolesFolderNode,
          runtimeRoleName,
          logicalRoleNames,
          phoNsPrefix);
    } else {
      throw new RuntimeException(
          Messages.getInstance()
              .getString(
                  "JcrRoleAuthorizationPolicyRoleBindingDao.ERROR_0001_ATTEMPT_MOD_IMMUTABLE",
                  runtimeRoleName)); //$NON-NLS-1$
    }
    session.save();
    Assert.isTrue(NodeHelper.hasNode(runtimeRolesFolderNode, phoNsPrefix, runtimeRoleName));

    // update cache
    String roleId = tenantedRoleNameUtils.getPrincipleId(tenant, runtimeRoleName);
    cacheManager.putInRegionCache(LOGICAL_ROLE_BINDINGS_REGION, roleId, logicalRoleNames);
  }
Example #27
0
 public static List<Node> getAuthorizedChildList(Node node) throws Exception {
   List<Node> children = new ArrayList<Node>();
   NodeIterator iter = node.getNodes();
   while (iter.hasNext()) {
     Node child = iter.nextNode();
     if (PermissionUtil.canRead(child)) children.add(child);
   }
   return children;
 }
Example #28
0
  @Test
  public void shouldCreateProjectionWithoutAlias() throws Exception {
    // link the first external document
    federationManager.createProjection("/testRoot", SOURCE_NAME, MockConnector.DOC1_LOCATION, null);
    assertEquals(1, testRoot.getNodes().getSize());

    Node doc1Federated = assertNodeFound("/testRoot" + MockConnector.DOC1_LOCATION);
    assertEquals(testRoot.getIdentifier(), doc1Federated.getParent().getIdentifier());
    assertEquals("a string", doc1Federated.getProperty("federated1_prop1").getString());
    assertEquals(12, doc1Federated.getProperty("federated1_prop2").getLong());
  }
 private ModelEMFResource getEMFResource(ModelId modelId) {
   try {
     Node folderNode = session.getNode(modelId.getFullPath());
     Node fileNode = (Node) folderNode.getNodes().next();
     Node fileItem = (Node) fileNode.getPrimaryItem();
     InputStream is = fileItem.getProperty("jcr:data").getBinary().getStream();
     return (ModelEMFResource) ModelParserFactory.getParser(fileNode.getName()).parse(is);
   } catch (Exception e) {
     throw new FatalModelRepositoryException("Something went wrong accessing the repository", e);
   }
 }
 /** {@inheritDoc} */
 public List<Node> getTemplatesByCategory(
     String portletName, String category, SessionProvider sessionProvider) throws Exception {
   Node basedApplicationTemplateHome = getBasedApplicationTemplatesHome(sessionProvider);
   Node applicationHome = basedApplicationTemplateHome.getNode(portletName);
   Node categoryNode = applicationHome.getNode(category);
   List<Node> templateNodes = new ArrayList<Node>();
   for (NodeIterator iterator = categoryNode.getNodes(); iterator.hasNext(); ) {
     templateNodes.add(iterator.nextNode());
   }
   return templateNodes;
 }