Start line:  
End line:  

Snippet Preview

Snippet HTML Code

Stack Overflow Questions
  package org.openl.rules.repository.jcr;
  
  import java.util.Calendar;
  import java.util.Date;
  
  import javax.jcr.Node;
 
JCR Node Utility

Author(s):
Aleh Bykhavets
 
 public class NodeUtil {

    
Checks whether type of the JCR node is correct.

Parameters:
nodeType expected node type
Throws:
javax.jcr.RepositoryException if failed
 
     protected static void checkNodeType(Node nodeString nodeTypethrows RepositoryException {
         if (!node.isNodeType(nodeType)) {
             String actualNodeType = node.getPrimaryNodeType().getName();
             throw new RepositoryException("Invalid NodeType '" + actualNodeType + "'. Expects '" + nodeType + "'!");
         }
     }
     
     public static boolean isVersionable(Node nodethrows RepositoryException {
         return node.isNodeType(.);
     }
 
     public static Calendar convertDate2Calendar(Date date) {
     	
         if (date == null) {
             return null;
         }
 
         Calendar c = Calendar.getInstance();
         c.setTime(date);
         return c;
     }
 
     protected static Node createFileNode(Node parentNodeString nodeNamethrows RepositoryException {
         Node n = createNode(parentNodenodeName.true);
         setupFileNode(n);
         return n;
     }

    
Creates node of given node type.

Parameters:
parentNode parent node, where new node is going to be added
name name of new node
type node type of new node
isVersionable whether new node is versionable
Returns:
reference on newly created node
Throws:
javax.jcr.RepositoryException if operation failed
 
     public static Node createNode(Node parentNodeString nameString typeboolean isVersionable)
             throws RepositoryException {
         if (parentNode.hasNode(name)) {
             throw new RepositoryException("Node '" + name + "' exists at '" + parentNode.getPath() + "' already!");
         }
 
         Node p = parentNode;
         while (p != null) {
             if (p.isCheckedOut()) {
                 break;
             } else {
                 if (p.isNodeType(.)) {
                     p.checkout();
                     break;
                 }
             }
 
             p = p.getParent();
         }
 
         Node n = parentNode.addNode(nametype);
         if (isVersionable) {
             n.addMixin(.);
         }
        return n;
    }
    protected static Node createProdFileNode(Node parentNodeString nodeNamethrows RepositoryException {
        Node n = createNode(parentNodenodeName.false);
        setupFileNode(n);
        return n;
    }
    protected static InputStream getFileNodeContent(Node nodethrows RRepositoryException {
        try {
        } catch (RepositoryException e) {
            throw new RRepositoryException("Failed to get Content!"e);
        }
    }
    protected static long getFileNodeSize(Node node) {
        long result;
        final Log log = LogFactory.getLog(NodeUtil.class);
        try {
            Node resNode = node.getNode(.);
            result = resNode.getProperty(.).getLength();
        } catch (RepositoryException e) {
            log.warn("getFileNodeSize"e);
            result = -1;
        }
        return result;
    }
    protected static Node getNode4Version(Node nodeCommonVersion versionthrows RepositoryException {
        Node result = null;
        VersionHistory vh = node.getVersionHistory();
        VersionIterator vi = vh.getAllVersions();
        while (vi.hasNext()) {
            Version jcrVersion = vi.nextVersion();
            if (NodeUtil.isRootVersion(jcrVersion)) {
                // TODO Shall we add first (0) version? (It is marker like, no
                // real values)
            } else {
                JcrVersion jvi = new JcrVersion(jcrVersion);
                CommonVersionImpl cv = new CommonVersionImpl(jvi.getRevision());
                if (cv.compareTo(version) == 0) {
                    result = jcrVersion.getNode(.);
                    break;
                }
            }
        }
        if (result == null) {
            throw new RepositoryException("Cannot find version '" + version.getVersionName() + "'!");
        }
        return result;
    }

    
Inquire whether given version is 'root'.

Parameters:
v version to be checked
Returns:
true if the version is root; false otherwise;
Throws:
javax.jcr.RepositoryException if operation failed
    protected static boolean isRootVersion(Version vthrows RepositoryException {
        String name = v.getName();
        return "jcr:rootVersion".equals(name);
    }
    public static boolean isSame(Object o1Object o2) {
        // both are null (the same)
        if (o1 == null && o2 == null) {
            return true;
        }
        // at least one is null (other is not)
        if (o1 == null || o2 == null) {
            return false;
        }
        // equals or not?
        return o1.equals(o2);
    }
    protected static Node normalizeOldNode(Node nodeCommonVersion versionthrows RepositoryException {
        if (node.isNodeType(.)) {
            // all is OK
            return node;
        }
        if (!node.isNodeType("nt:versionedChild")) {
            // ??? unknown
            return node;
        }
        Node versionHistoryNode = node.getProperty("jcr:childVersionHistory").getNode();
        int projectRevision = version.getRevision();
        int correctVRev = -1;
        Node correctVNode = null;
        NodeIterator versions = versionHistoryNode.getNodes();
        while (versions.hasNext()) {
            Node versionNode = versions.nextNode();
            if (!versionNode.isNodeType("nt:version")) {
                continue;
            }
            // old nodes, should be 1 per versionNode
            NodeIterator oldNodes = versionNode.getNodes();
            while (oldNodes.hasNext()) {
                Node oldNode = oldNodes.nextNode();
                int nodeRevision = 0;
                if (oldNode.hasProperty(.)) {
                    nodeRevision = (intoldNode.getProperty(.).getLong();
                }
                if (nodeRevision <= projectRevision) {
                    if (nodeRevision > correctVRev) {
                        correctVNode = oldNode;
                        correctVRev = nodeRevision;
                    }
                }
            }
        }
        return correctVNode;
    }
    protected static void printNode(Node nodethrows RepositoryException {
        ..println("Node: " + node.getName());
        PropertyIterator pi = node.getProperties();
        while (pi.hasNext()) {
            Property p = pi.nextProperty();
            boolean isProtected = p.getDefinition().isProtected();
            boolean isMultiple = p.getDefinition().isMultiple();
            String status = "";
            if (isProtected) {
                status = "protected";
            }
            if (isMultiple) {
                ..println(" p " + p.getName() + " multiple " + status);
            } else {
                ..println(" p " + p.getName() + " " + status + " =" + p.getString());
            }
        }
    }
    private static void setupFileNode(Node nthrows RepositoryException {
        String mimeType = "text/plain";
        String encoding = "UTF-8";
        long lastModifiedTime = System.currentTimeMillis();
        Calendar lastModified = Calendar.getInstance();
        lastModified.setTimeInMillis(lastModifiedTime);
        // create the file node - see section 6.7.22.6 of the spec
        // create the mandatory child node - jcr:content
        resNode.setProperty(.mimeType);
        resNode.setProperty(.encoding);
        // TODO add real init-content
        resNode.setProperty(.new ByteArrayInputStream(new byte[0]));
        resNode.setProperty(.lastModified);
    }

    
Checkout node and parent (if needed).

Parameters:
node reference on node to be checked in
openParent whether parent should be checked out
Throws:
javax.jcr.RepositoryException if operation failed
    public static void smartCheckout(Node nodeboolean openParentthrows RepositoryException {
        if (!node.isCheckedOut()) {
            if (node.isNodeType(.)) {
                node.checkout();
            }
        }
        if (openParent) {
            Node parentNode = node.getParent();
            if (!parentNode.isCheckedOut()) {
                parentNode.checkout();
            }
        }
    }
New to GrepCode? Check out our FAQ X