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

Author(s):
Aleh Bykhavets
 
 public class JcrEntity extends JcrCommonArtefact implements REntity {
     private final Log log = LogFactory.getLog(JcrEntity.class);
     private static final String[] ALLOWED_PROPS = {};
 
     private Date effectiveDate;
     private Date expirationDate;
 
     private String lineOfBusiness;
 
     private Map<StringObjectprops;
 
     private JcrLock lock;
     private JcrVersion version;
 
 
     // ------ protected methods ------
 
     public JcrEntity(Node nodethrows RepositoryException {
         super(node);
          = new JcrLock(node);
          = new JcrVersion(node);
 
         if (node.hasProperty(.)) {
         }
         if (node.hasProperty(.)) {
         }
         if (node.hasProperty(.)) {
         }
 
          = new HashMap<Stringorg.openl.rules.common.Property>();
         initProperties();
          = new HashMap<StringObject>();
         loadProps();
     }
 
     public void addProperty(String nameValueType typeObject valuethrows RRepositoryException {
         try {
             NodeUtil.smartCheckout(node(), false);
         } catch (RepositoryException e) {
             throw new RRepositoryException("Internal error."e);
         }
 
         if (hasProperty(name)) {
             removeProperty(name);
         }
 
         JcrProperty jp = new JcrProperty(node(), nametypevalue);
         .put(namejp);
     }
 
     private void buildRelPath(StringBuilder sbNode nthrows RepositoryException {
         if (!n.isNodeType(.)) {
             buildRelPath(sbn.getParent());
         }
 
         if (!n.isNodeType(.)) {
             sb.append('/');
             sb.append(n.getName());
        }
    }
    public Date getEffectiveDate() {
        return ;
    }
    public Date getExpirationDate() {
        return ;
    }
    public String getLineOfBusiness() {
        return ;
    }
    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();
    }
        org.openl.rules.common.Property rp = .get(name);
        try {
            if (node().hasProperty(name)) {
                Property p = node().getProperty(name);
                rp = new JcrProperty(node(), p);
                .put(namerp);
            }
        } catch (RepositoryException e) {
            throw new RRepositoryException(String.format("Failed to get property \"%s\""name), e);
        }
        if (rp == null) {
            throw new RRepositoryException("No such property ''{0}''."nullname);
        }
        return rp;
    }
    public Map<StringObjectgetProps() {
        return ;
    }
    public boolean hasProperty(String name) {
        return (.get(name) != null);
    }
    private void initProperties() throws RepositoryException {
        .clear();
        Node n = node();
        for (String s : ) {
            if (n.hasProperty(s)) {
                Property p = n.getProperty(s);
                JcrProperty prop = new JcrProperty(node(), p);
                .put(prop.getName(), prop);
            }
        }
    }
    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);
            }
        }
    }
    public void removeProperty(String namethrows RRepositoryException {
        org.openl.rules.common.Property rp = .get(name);
        if (rp == null) {
            throw new RRepositoryException("No such property ''{0}''."nullname);
        }
        Node n = node();
        try {
            NodeUtil.smartCheckout(nfalse);
        } catch (RepositoryException e) {
            throw new RRepositoryException("Internal error."e);
        }
        try {
            n.getProperty(name).remove();
        } catch (RepositoryException e) {
            throw new RRepositoryException("Cannot remove property ''{0}''."ename);
        }
        .remove(name);
    }
    public void setEffectiveDate(Date datethrows RRepositoryException {
        // do not update JCR if property wasn't changed
        if (isSame(date)) {
            return;
        }
        Node n = node();
        Calendar c = convertDate2Calendar(date);
        try {
            NodeUtil.smartCheckout(nfalse);
            n.setProperty(.c);
             = date;
        } catch (RepositoryException e) {
            throw new RRepositoryException("Cannot set effectiveDate."e);
        }
    }
    // ------ private ------
    public void setExpirationDate(Date datethrows RRepositoryException {
        // do not update JCR if property wasn't changed
        if (isSame(date)) {
            return;
        }
        Node n = node();
        Calendar c = convertDate2Calendar(date);
        try {
            NodeUtil.smartCheckout(nfalse);
             = date;
        } catch (RepositoryException e) {
            throw new RRepositoryException("Cannot set expirationDate."e);
        }
    }
    public void setLineOfBusiness(String lineOfBusinessthrows RRepositoryException {
        // do not update JCR if property wasn't changed
        if (isSame(this.lineOfBusiness)) {
            return;
        }
        Node n = node();
        try {
            NodeUtil.smartCheckout(nfalse);
            n.setProperty(.lineOfBusiness);
            this. = lineOfBusiness;
        } catch (RepositoryException e) {
            throw new RRepositoryException("Cannot set LOB."e);
        }
    }
    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);
            }
        } catch (RepositoryException e) {
            throw new RRepositoryException("Cannot set property " + propName + "."e);
        }
    }
    public void setProps(Map<StringObjectpropsthrows RRepositoryException {
        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);
            setProperty(propNamepropValue);
        }
        this. = props;
    }
    public RLock getLock() throws RRepositoryException {
        return ;
    }
    public boolean isLocked() throws RRepositoryException {
        return .isLocked();
    }
    public void lock(CommonUser userthrows RRepositoryException {
        .lock(user);
    }
    public void unlock(CommonUser userthrows RRepositoryException {
        .unlock(user);
    }
    public void commit(CommonUser userthrows RRepositoryException {
        try {
            Node n = node();
            NodeUtil.smartCheckout(ntrue);
            .nextRevision();
            .updateVersion(n);
            checkInAll(nuser);
            commitParent(n.getParent());
        } catch (RepositoryException e) {
            throw new RRepositoryException("Failed to checkin project ''{0}''!"egetName());
        }
    }
    protected void commitParent(Node parentthrows RepositoryException {
        if (parent.isModified()) {
            parent.save();
        }
        if (parent.isCheckedOut()) {
            if (parent.isNodeType(.)) {
                parent.checkin();
            }
        }
    }
    protected void checkInAll(Node nCommonUser userthrows RepositoryException {
        NodeIterator ni = n.getNodes();
        while (ni.hasNext()) {
            Node child = ni.nextNode();
            checkInAll(childuser);
        }
        boolean saveProps = false;
        PropertyIterator pi = n.getProperties();
        while (pi.hasNext()) {
            Property p = pi.nextProperty();
            if (p.isModified() || p.isNew()) {
                saveProps = true;
                break;
            }
        }
        boolean mustBeSaved = (saveProps || n.isModified() || n.isNew());
        boolean mustBeCheckedIn = (n.isNodeType(.) && n.isCheckedOut());
        if (mustBeCheckedIn) {
            .updateRevision(n);
            n.setProperty(.user.getUserName());
            n.save();
            .info("Checking in... " + n.getPath());
            n.checkin();
        } else if (mustBeSaved) {
            .info("Saving... " + n.getPath());
            n.save();
        }
    }
New to GrepCode? Check out our FAQ X