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 java.util.Set;
 
 import javax.jcr.Node;
 
 
 import static org.openl.rules.repository.jcr.NodeUtil.isSame;
 
Implementation of JCR Entity. It is linked with node in JCR implementation, always.

Author(s):
Aleh Bykhavets
 
 public class JcrEntityAPI extends JcrCommonArtefact implements ArtefactAPI {
     private final Log log = LogFactory.getLog(JcrEntityAPI.class);
 
     private Map<StringObjectprops;
 
     private JcrVersion version;
     private ArtefactPath path;
 
     // ------ protected methods ------
 
     public JcrEntityAPI(Node nodeRTransactionManager transactionManagerArtefactPath pathboolean oldVersionthrows RepositoryException {
         super(nodepath.segment(path.segmentCount() - 1), oldVersion);
         this. = path;
         this. = transactionManager;
          = new JcrVersion(node);
 
          = new HashMap<Stringorg.openl.rules.common.Property>();
         initProperties();
          = new HashMap<StringObject>();
         loadProps();
     }
 
     public void addProperty(String nameValueType typeObject valuethrows PropertyException {
         if (hasProperty(name)) {
             removeProperty(name);
         }
 
         if (value != null) {
             try {
                 NodeUtil.smartCheckout(node(), false);
                 JcrProperty jp;
                 try {
                     jp = new JcrProperty(node(), nametypevalue);
                 } catch (RRepositoryException e) {
                     throw new PropertyException("Internal error."e);
                 }
                 .put(namejp);
                 node().save();
             } catch (RepositoryException e) {
                 throw new PropertyException("Internal error."e);
             }
         }
     }
 
     private void buildRelPath(StringBuilder sbNode nthrows RepositoryException {
         if (!n.isNodeType(.)) {
             buildRelPath(sbn.getParent());
         }
 
        if (!n.isNodeType(.)) {
            sb.append('/');
            sb.append(n.getName());
        }
    }
    public String getPath() throws RRepositoryException {
        StringBuilder sb = new StringBuilder(128);
        try {
            buildRelPath(sbnode());
        } catch (RepositoryException e) {
            throw new RRepositoryException("Failed to get relative path."e);
        }
        return sb.toString();
    }
        return .values();
    }
    public org.openl.rules.common.Property getProperty(String namethrows PropertyException {
        org.openl.rules.common.Property rp = .get(name);
        try {
            if (node().hasProperty(name)) {
                rp = new JcrProperty(node(), node().getProperty(name));
                .put(namerp);
            }
        } catch (Exception e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
        if (rp == null) {
            throw new PropertyException("No such property ''{0}''."nullname);
        }
        return rp;
    }
    public Map<StringObjectgetProps() {
        return ;
    }
    public boolean hasProperty(String name) {
        if (.containsKey(name)) {
            return true;
        }
        try {
            return node().hasProperty(name);
        } catch (RepositoryException e) {
            return false;
        }
    }
    private void initProperties() throws RepositoryException {
        .clear();
        Node n = node();
        for (String s : ) {
            if (n.hasProperty(s)) {
                Property p = n.getProperty(s);
                .put(snew JcrProperty(node(), p));
            }
        }
    }
    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 = new Date(value.getLong());
                        break;
                    case .:
                        propValue = value.getDouble();
                        break;
                    default:
                        propValue = value.getString();
                        break;
                }
                .put(propNamepropValue);
            }
        }
    }
        org.openl.rules.common.Property rp = getProperty(name);
        if (rp == null) {
            throw new PropertyException("No such property ''{0}''."nullname);
        }
        Node n = node();
        try {
            NodeUtil.smartCheckout(nfalse);
            n.getProperty(name).remove();
            n.save();
        } catch (RepositoryException e) {
            throw new PropertyException("Cannot remove property ''{0}''."ename);
        }
        return .remove(name);
    }
    private void setProperty(String propNameObject propValuethrows RRepositoryException {
        Node n = node();
        try {
            NodeUtil.smartCheckout(nfalse);
            if (propValue instanceof Date) {
                n.setProperty(propName, ((DatepropValue).getTime());
            } else if (propValue instanceof Double) {
                n.setProperty(propName, (DoublepropValue);
            } else {
                n.setProperty(propName, (StringpropValue);
            }
            n.save();
        } catch (RepositoryException e) {
            throw new RRepositoryException("Cannot set property " + propName + "."e);
        }
    }
    public void setProps(Map<StringObjectpropsthrows PropertyException {
        if (props == null) {
            return;
        }
        // do not update JCR if property wasn't changed
        if (isSame(this.props)) {
            return;
        }
        Set<StringpropNames = props.keySet();
        for (String propName : propNames) {
            Object propValue = props.get(propName);
            try {
                setProperty(propNamepropValue);
            } catch (RRepositoryException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }
        }
        this. = props;
    }
    public RLock getLock() throws RRepositoryException {
        if (isOldVersion()) {
            return .;
        } else {
            try {
                return new JcrLock(node());
            } catch (RepositoryException e) {
                throw new RRepositoryException("Failed to get lock."e);
            }
        }
    }
    public boolean isLocked() throws RRepositoryException {
        return getLock().isLocked();
    }
    public void lock(CommonUser userthrows ProjectException {
        try {
            getLock().lock(user);
        } catch (RRepositoryException e) {
            throw new ProjectException(""e);
        }
    }
    public void unlock(CommonUser userthrows ProjectException {
        try {
            getLock().unlock(user);
        } catch (RRepositoryException e) {
            throw new ProjectException(""e);
        }
    }
    
    private void saveParent(Node nodethrows RepositoryException{
        Node parent = node.getParent();
        if (parent.isNew()) {
            saveParent(parent);
        } else if (parent.isModified()) {
            parent.save();
        }
    }
    public void delete(CommonUser userthrows ProjectException {
        try {
            if(isLocked()){
                unlock(user);
            }
            delete();
        } catch (Exception e) {
            throw new ProjectException("Failed to delete node."e);
        }
    }
    public ArtefactPath getArtefactPath() {
        return ;
    }
    public boolean isFolder() {
        return false;
    }
    public ProjectVersion getVersion() {
        // FIXME
        RVersion rv = getActiveVersion();
        return new RepositoryProjectVersionImpl(rvrvii);
    }
    public List<ProjectVersiongetVersions() {
        // FIXME
        LinkedList<ProjectVersionvers = new LinkedList<ProjectVersion>();
        try {
            for (RVersion rv : getVersionHistory()) {
                RepositoryVersionInfoImpl rvii = new RepositoryVersionInfoImpl(rv.getCreated(), rv.getCreatedBy()
                        .getUserName());
                vers.add(new RepositoryProjectVersionImpl(rvrvii));
            }
        } catch (RRepositoryException e) {
            .error("Failed to get version history!"e);
        }
        return vers;
    }
    public LockInfo getLockInfo() {
        // FIXME
        try {
            return getLock();
        } catch (RRepositoryException e) {
            .error("getLockInfo"e);
            return .;
        }
    }
    public void commit(CommonUser userint majorint minorint revisionthrows ProjectException {
        try {
            Node n = node();
            saveParent(n);
            NodeUtil.smartCheckout(nfalse);
            .set(majorminorrevision);
            .updateVersion(n);
            n.setProperty(.user.getUserName());
            if (NodeUtil.isVersionable(n)) {
                .info("Checking in... " + n.getPath());
                n.save();
                n.checkin();
            } else {
                n.save();
                .info("Saving... " + n.getPath());
            }
        } catch (RepositoryException e) {
            throw new ProjectException("Failed to check in artefact ''{0}''!"egetPath());
        }
    }
    public JcrEntityAPI getVersion(CommonVersion versionthrows RRepositoryException{
        try {
            Node frozenNode = NodeUtil.getNode4Version(node(), version);
            return new JcrEntityAPI(frozenNodegetTransactionManager(), getArtefactPath(), true);
        } catch (RepositoryException e) {
            throw new RRepositoryException("Failed to get version for node."e);
        }
    }
    public void removeAllProperties() throws PropertyException {
        List<StringpropertyNames = new ArrayList<String>(.keySet());
        for(String propertyName : propertyNames){
            removeProperty(propertyName);
        }
        .clear();
    }
    public boolean isModified() {
        //FIXME always false
        return node().isModified();
    }
        return ;
    }
        return getTransactionManager().getTransaction();
    }
New to GrepCode? Check out our FAQ X