Start line:  
End line:  

Snippet Preview

Snippet HTML Code

Stack Overflow Questions
  package org.openl.rules.repository.jcr;
  
  import java.util.Date;
  import java.util.HashMap;
  import java.util.List;
  import java.util.Map;
  
 import javax.jcr.Node;
 
 
 public class JcrOldEntity implements REntity {
     private Node node;
     private String name;
 
     private JcrVersion version;
     private JcrOldEntity parent;
 
     private Date effectiveDate;
     private Date expirationDate;
     private String lineOfBusiness;
 
     private Map<StringObjectprops;
 
     public JcrOldEntity(JcrOldEntity parentString nameNode nodethrows RepositoryException {
         this. = parent;
         this. = node;
         this. = name;
 
          = new JcrVersion(node);
 
         if (node.hasProperty(.)) {
         }
         if (node.hasProperty(.)) {
         }
         if (node.hasProperty(.)) {
         }
 
          = new HashMap<StringObject>();
         loadProps();
     }
 
     public void addProperty(String nameValueType typeObject valuethrows RRepositoryException {
         notSupported();
     }

    
Checks whether type of the JCR node is correct. Checks FROZEN Type

Parameters:
frozenNodeType expected node type
Throws:
javax.jcr.RepositoryException if failed
 
     protected void checkNodeType(String frozenNodeTypethrows RepositoryException {
         if (!.isNodeType(.)) {
             throw new RepositoryException("Not a frozen node!");
         }
 
         String actualFrozenNodeType = .getProperty("jcr:frozenPrimaryType").getString();
         if (..equals(actualFrozenNodeType) && ..equals(frozenNodeType)) {
             // openl:files -- openl:folder
             return;
         }
 
         if (!frozenNodeType.equals(actualFrozenNodeType)) {
             throw new RepositoryException("Invalid NodeType '" + actualFrozenNodeType + "'. Expects '" + frozenNodeType
                     + "'.");
         }
     }
 
     public void delete() throws RRepositoryException {
         notSupported();
     }
 
     public RVersion getActiveVersion() {
         return ;
     }
 
     public Date getEffectiveDate() {
         return ;
     }
 
     public Date getExpirationDate() {
         return ;
     }
    public String getLineOfBusiness() {
        return ;
    }
    public String getName() {
        return ;
    }
    public String getPath() throws RRepositoryException {
        JcrOldEntity curr = this;
        StringBuilder sb = new StringBuilder(128);
        while (curr != null) {
            String s = curr.getName();
            if (s != null) {
                sb.insert(0, s);
                sb.insert(0, '/');
            }
            curr = curr.parent;
        }
        return sb.toString();
    }
        // not supported
        return null;
    }
        try {
            if (node().hasProperty(name)) {
                Property p = node().getProperty(name);
                return new JcrProperty(node(), p);
            }else{
                return null;
            }
        } catch (Exception e) {
            throw new RRepositoryException("Cannot find property"e);
        }
    }
    public Map<StringObjectgetProps() {
        return ;
    }
    public List<RVersiongetVersionHistory() throws RRepositoryException {
        LinkedList<RVersionresult = new LinkedList<RVersion>();
        // only current version
        result.add();
        return result;
    }
    public boolean hasProperty(String name) {
        // not supported
        return false;
    }
    private void loadProps() throws RepositoryException {
        Node n = node();
        for (int i = 1; i <= .i++) {
            String propName = . + i;
            if (n.hasProperty(propName)) {
                Value value = n.getProperty(propName).getValue();
                Object propValue = null;
                int valueType = value.getType();
                switch (valueType) {
                    case .:
                        propValue = value.getDate().getTime();
                        break;
                    case .:
                        propValue = value.getDouble();
                        break;
                    default:
                        propValue = value.getString();
                        break;
                }
                .put(propNamepropValue);
            }
        }
    }
    protected Node node() {
        return ;
    }
    protected void notSupported() throws RRepositoryException {
        throw new RRepositoryException("Cannot modify artefact version!"null);
    }
    public void removeProperty(String namethrows RRepositoryException {
        notSupported();
    }
    // --- protected
    public void setEffectiveDate(Date datethrows RRepositoryException {
        notSupported();
    }
    public void setExpirationDate(Date datethrows RRepositoryException {
        notSupported();
    }
    public void setLineOfBusiness(String lineOfBusinessthrows RRepositoryException {
        notSupported();
    }
    public void setProps(Map<StringObjectpropsthrows RRepositoryException {
        notSupported();
    }
    public RLock getLock() throws RRepositoryException {
        // not supported
        return .;
    }
    public boolean isLocked() throws RRepositoryException {
        // cannot be locked
        return false;
    }
    public void lock(CommonUser userthrows RRepositoryException {
        notSupported();
    }
    public void unlock(CommonUser userthrows RRepositoryException {
        notSupported();
    }
    public void commit(CommonUser userthrows RRepositoryException {
        notSupported();
    }
    public void riseVersion(int majorint minorthrows RRepositoryException {
        notSupported();
    }
New to GrepCode? Check out our FAQ X