Start line:  
End line:  

Snippet Preview

Snippet HTML Code

Stack Overflow Questions
  package org.openl.rules.repository.jcr;
  
  import java.util.List;
  
  import javax.jcr.Node;
 
Implementation for JCR Repository. One JCR Repository instance per user.

Author(s):
Aleh Bykhavets
 
 public class JcrRepository extends BaseJcrRepository {
     private final Log log = LogFactory.getLog(JcrRepository.class);
     private static final String QUERY_PROJECTS = "//element(*, " + . + ")";
     private static final String QUERY_PROJECTS_4_DEL = "//element(*, " + . + ") [@"
             + . + "]";
     private static final String QUERY_DDPROJECTS = "//element(*, " + . + ")";
 
     private Node defRulesLocation;
     private Node defDeploymentsLocation;
 
 
     public JcrRepository(String nameSession sessionRTransactionManager transactionManagerString defRulesPathString defDeploymentsPath)
             throws RepositoryException {
         super(namesessiontransactionManager);
 
          = checkPath(defRulesPath);
          = checkPath(defDeploymentsPath);
 
         if (.isNew() || .isNew()) {
             // save all at once
             session.save();
         }
         
         session.getWorkspace()
                 .getObservationManager()
                 .addEventListener(this. | .session.getRootNode().getPath(),
                         truenullnullfalse);
 
     }
 
     @Deprecated
         try {
             return JcrDeploymentDescriptorProject.createProject(nodeName);
         } catch (RepositoryException e) {
             throw new RRepositoryException("Failed to create DDProject ''{0}''."enodeName);
         }
     }
 
     @Deprecated
     public RProject createProject(String nodeNamethrows RRepositoryException {
         try {
             return JcrProject.createProject(nodeName);
         } catch (RepositoryException e) {
             throw new RRepositoryException("Failed to create Project ''{0}''."enodeName);
         }
     }
 
     @Deprecated
         try {
             if (!.hasNode(name)) {
                 throw new RRepositoryException("Cannot find Project ''{0}''."nullname);
             }
 
             Node n = .getNode(name);
             JcrDeploymentDescriptorProject ddp = new JcrDeploymentDescriptorProject(n);
             return ddp;
         } catch (RepositoryException e) {
             throw new RRepositoryException("Failed to get DDProject ''{0}''."ename);
         }
     }
 
    @Deprecated
        NodeIterator ni = runQuery();
        while (ni.hasNext()) {
            Node n = ni.nextNode();
            try {
                JcrDeploymentDescriptorProject ddp = new JcrDeploymentDescriptorProject(n);
                result.add(ddp);
            } catch (RepositoryException e) {
                .debug("Failed to add deployment project.");
            }
        }
        return result;
    }
    @Deprecated
    public RProject getProject(String namethrows RRepositoryException {
        try {
            if (!.hasNode(name)) {
                throw new RRepositoryException("Cannot find project ''{0}''"nullname);
            }
            Node n = .getNode(name);
            JcrProject p = new JcrProject(n);
            return p;
        } catch (RepositoryException e) {
            throw new RRepositoryException("Failed to get project ''{0}''"ename);
        }
    }
    @Deprecated
    public List<RProjectgetProjects() throws RRepositoryException {
        // TODO list all or only that are active (not marked4deletion)?
        NodeIterator ni = runQuery();
        LinkedList<RProjectresult = new LinkedList<RProject>();
        while (ni.hasNext()) {
            Node n = ni.nextNode();
            try {
                JcrProject p = new JcrProject(n);
                result.add(p);
            } catch (RepositoryException e) {
                .debug("Failed to add rules project.");
            }
        }
        return result;
    }
    @Deprecated
        LinkedList<RProjectresult = new LinkedList<RProject>();
        while (ni.hasNext()) {
            Node n = ni.nextNode();
            try {
                JcrProject p = new JcrProject(n);
                result.add(p);
            } catch (RepositoryException e) {
                .debug("Failed to add rules project for deletion.");
            }
        }
        return result;
    }
    public boolean hasDeploymentProject(String namethrows RRepositoryException {
        try {
            return .hasNode(name);
        } catch (RepositoryException e) {
            throw new RRepositoryException("Failed to check project ''{0}''"ename);
        }
    }
    // ------ protected methods ------

    
    public boolean hasProject(String namethrows RRepositoryException {
        try {
            return .hasNode(name);
        } catch (RepositoryException e) {
            throw new RRepositoryException("Failed to check project ''{0}''"ename);
        }
    }

    
Runs query in JCR.

Parameters:
statement query statement
Returns:
list of OpenL projects
Throws:
org.openl.rules.repository.exceptions.RRepositoryException if failed
    protected NodeIterator runQuery(String statementthrows RRepositoryException {
        try {
            QueryManager qm = getSession().getWorkspace().getQueryManager();
            Query query = qm.createQuery(statement.);
            QueryResult qr = query.execute();
            return qr.getNodes();
        } catch (RepositoryException e) {
            throw new RRepositoryException("Failed to run query."e);
        }
    }
        try {
            Node node = NodeUtil.createNode(name,
                    .true);
            .save();
            node.checkin();
            return new JcrFolderAPI(nodegetTransactionManager(), new ArtefactPathImpl(new String[] { name })); 
        } catch (RepositoryException e) {
            throw new RRepositoryException("Failed to create deployment project."e);
        }
    }
    public FolderAPI createRulesProject(String namethrows RRepositoryException {
        try {
            Node node = NodeUtil.createNode(name,
                    .true);
            .save();
            node.checkin();
            return new JcrFolderAPI(nodegetTransactionManager(), new ArtefactPathImpl(new String[] { name })); 
        } catch (RepositoryException e) {
            throw new RRepositoryException("Failed to create rules project."e);
        }
    }
    public FolderAPI getDeploymentProject(String namethrows RRepositoryException {
        try {
            if (!.hasNode(name)) {
                throw new RRepositoryException("Cannot find Project ''{0}''."nullname);
            }
            Node n = .getNode(name);
            return new JcrFolderAPI(ngetTransactionManager(), new ArtefactPathImpl(new String[] { name }));
        } catch (RepositoryException e) {
            throw new RRepositoryException("Failed to get DDProject ''{0}''."ename);
        }
    }
        NodeIterator ni;
        try {
            ni = .getNodes();
        } catch (RepositoryException e) {
            throw new RRepositoryException("Cannot get any deployment project"e); 
        }
        LinkedList<FolderAPIresult = new LinkedList<FolderAPI>();
        while (ni.hasNext()) {
            Node n = ni.nextNode();
            try {
                if (!n.isNodeType(.)) {
                    result.add(new JcrFolderAPI(ngetTransactionManager(), new ArtefactPathImpl(new String[] { n.getName() })));
                }
            } catch (RepositoryException e) {
                .debug("Failed to add deployment project.");
            }
        }
        return result;
    }
    public FolderAPI getRulesProject(String namethrows RRepositoryException {
        try {
            if (!.hasNode(name)) {
                throw new RRepositoryException("Cannot find project ''{0}''"nullname);
            }
            Node n = .getNode(name);
            return new JcrFolderAPI(ngetTransactionManager(), new ArtefactPathImpl(new String[] { name }));
        } catch (RepositoryException e) {
            throw new RRepositoryException("Failed to get project ''{0}''"ename);
        }
    }
    public List<FolderAPIgetRulesProjects() throws RRepositoryException {
        NodeIterator ni;
        try {
            ni = .getNodes();
        } catch (RepositoryException e) {
            throw new RRepositoryException("Cannot get any rules project"e); 
        }
        LinkedList<FolderAPIresult = new LinkedList<FolderAPI>();
        while (ni.hasNext()) {
            Node n = ni.nextNode();
            try {
                if (!n.isNodeType(.)) {
                    result.add(new JcrFolderAPI(ngetTransactionManager(), new ArtefactPathImpl(new String[] { n.getName() })));
                }
            } catch (RepositoryException e) {
                .debug("Failed to add rules project.");
            }
        }
        return result;
    }
        NodeIterator ni = runQuery("//element(*, " + . + ") [@"
                + . + "]");
        LinkedList<FolderAPIresult = new LinkedList<FolderAPI>();
        while (ni.hasNext()) {
            Node n = ni.nextNode();
            try {
                result.add(new JcrFolderAPI(ngetTransactionManager(), new ArtefactPathImpl(new String[] { n.getName() })));
            } catch (RepositoryException e) {
                .debug("Failed to add rules project for deletion.");
            }
        }
        return result;
    }
    
    private static String CHECKED_OUT_PROPERTY = "jcr:isCheckedOut";
    
    private String extractProjectName(String relativePath){
        return new ArtefactPathImpl(relativePath).segment(0);
    }
    
    private boolean isProjectDeletedEvent(Event eventString relativePath){
        ArtefactPathImpl path = new ArtefactPathImpl(relativePath);
        if (path.segmentCount() == 1 && event.getType() == .) {
            return true;
        } else {
            return false;
        }
    }
    
    private boolean isProjectModifiedEvent(Event eventString relativePath){
        if (relativePath.contains()) {
            return true;
        }else{
            return false;
        }
    }
    public void onEvent(EventIterator eventIterator) {
        while (eventIterator.hasNext()) {
            Event event = eventIterator.nextEvent();
            try {
                if (event.getPath().startsWith(.getPath())) {
                    String relativePath = StringUtils.removeStart(event.getPath(), .getPath() + "/");
                    if (isProjectDeletedEvent(eventrelativePath) || isProjectModifiedEvent(eventrelativePath)) {
                        for (RRepositoryListener listener : ) {
                            listener.onEventInRulesProjects(new RRepositoryEvent(extractProjectName(relativePath)));
                        }
                    }
                } else if (event.getPath().startsWith(.getPath())) {
                    String relativePath = StringUtils.removeStart(event.getPath(), .getPath()
                            + "/");
                    if (isProjectDeletedEvent(eventrelativePath) || isProjectModifiedEvent(eventrelativePath)) {
                        for (RRepositoryListener listener : ) {
                            listener.onEventInDeploymentProjects(new RRepositoryEvent(extractProjectName(relativePath)));
                        }
                    }
                }
            } catch (RepositoryException e) {
                .error(e);
            }
        }
    }
    public void addRepositoryListener(RRepositoryListener listener) {
        .add(listener);
    }
    public void removeRepositoryListener(RRepositoryListener listener) {
        .remove(listener);
    }
        return ;
    }
New to GrepCode? Check out our FAQ X