X-Git-Url: http://git.argeo.org/?a=blobdiff_plain;f=server%2Fruntime%2Forg.argeo.server.jcr%2Fsrc%2Fmain%2Fjava%2Forg%2Fargeo%2Fjcr%2FJcrUtils.java;h=b862e8fc4da2fec04be3bb76a25b6e015cdb37a5;hb=7807780029af8d1f2f32d7513e0769f128b729d1;hp=b7dfdffc3d81e0e4c686f240848606b34595cf26;hpb=5df15109891c3afec75fa8621375ae8af10bb802;p=lgpl%2Fargeo-commons.git

diff --git a/server/runtime/org.argeo.server.jcr/src/main/java/org/argeo/jcr/JcrUtils.java b/server/runtime/org.argeo.server.jcr/src/main/java/org/argeo/jcr/JcrUtils.java
index b7dfdffc3..b862e8fc4 100644
--- a/server/runtime/org.argeo.server.jcr/src/main/java/org/argeo/jcr/JcrUtils.java
+++ b/server/runtime/org.argeo.server.jcr/src/main/java/org/argeo/jcr/JcrUtils.java
@@ -21,7 +21,11 @@ import java.text.ParseException;
 import java.util.Calendar;
 import java.util.Date;
 import java.util.GregorianCalendar;
+import java.util.Iterator;
+import java.util.List;
+import java.util.Map;
 import java.util.StringTokenizer;
+import java.util.TreeMap;
 
 import javax.jcr.NamespaceRegistry;
 import javax.jcr.Node;
@@ -292,4 +296,193 @@ public class JcrUtils {
 		}
 
 	}
+
+	/**
+	 * Copies recursively the content of a node to another one. Mixin are NOT
+	 * copied.
+	 */
+	public static void copy(Node fromNode, Node toNode) {
+		try {
+			PropertyIterator pit = fromNode.getProperties();
+			properties: while (pit.hasNext()) {
+				Property fromProperty = pit.nextProperty();
+				String propertyName = fromProperty.getName();
+				if (toNode.hasProperty(propertyName)
+						&& toNode.getProperty(propertyName).getDefinition()
+								.isProtected())
+					continue properties;
+
+				toNode.setProperty(fromProperty.getName(),
+						fromProperty.getValue());
+			}
+
+			NodeIterator nit = fromNode.getNodes();
+			while (nit.hasNext()) {
+				Node fromChild = nit.nextNode();
+				Integer index = fromChild.getIndex();
+				String nodeRelPath = fromChild.getName() + "[" + index + "]";
+				Node toChild;
+				if (toNode.hasNode(nodeRelPath))
+					toChild = toNode.getNode(nodeRelPath);
+				else
+					toChild = toNode.addNode(fromChild.getName(), fromChild
+							.getPrimaryNodeType().getName());
+				copy(fromChild, toChild);
+			}
+		} catch (RepositoryException e) {
+			throw new ArgeoException("Cannot copy " + fromNode + " to "
+					+ toNode, e);
+		}
+	}
+
+	/**
+	 * Check whether all first-level properties (except jcr:* properties) are
+	 * equal. Skip jcr:* properties
+	 */
+	public static Boolean allPropertiesEquals(Node reference, Node observed,
+			Boolean onlyCommonProperties) {
+		try {
+			PropertyIterator pit = reference.getProperties();
+			props: while (pit.hasNext()) {
+				Property propReference = pit.nextProperty();
+				String propName = propReference.getName();
+				if (propName.startsWith("jcr:"))
+					continue props;
+
+				if (!observed.hasProperty(propName))
+					if (onlyCommonProperties)
+						continue props;
+					else
+						return false;
+				// TODO: deal with multiple property values?
+				if (!observed.getProperty(propName).getValue()
+						.equals(propReference.getValue()))
+					return false;
+			}
+			return true;
+		} catch (RepositoryException e) {
+			throw new ArgeoException("Cannot check all properties equals of "
+					+ reference + " and " + observed, e);
+		}
+	}
+
+	public static Map<String, PropertyDiff> diffProperties(Node reference,
+			Node observed) {
+		Map<String, PropertyDiff> diffs = new TreeMap<String, PropertyDiff>();
+		diffPropertiesLevel(diffs, null, reference, observed);
+		return diffs;
+	}
+
+	/**
+	 * Compare the properties of two nodes. Recursivity to child nodes is not
+	 * yet supported. Skip jcr:* properties.
+	 */
+	static void diffPropertiesLevel(Map<String, PropertyDiff> diffs,
+			String baseRelPath, Node reference, Node observed) {
+		try {
+			// check removed and modified
+			PropertyIterator pit = reference.getProperties();
+			props: while (pit.hasNext()) {
+				Property p = pit.nextProperty();
+				String name = p.getName();
+				if (name.startsWith("jcr:"))
+					continue props;
+
+				if (!observed.hasProperty(name)) {
+					String relPath = propertyRelPath(baseRelPath, name);
+					PropertyDiff pDiff = new PropertyDiff(PropertyDiff.REMOVED,
+							relPath, p.getValue(), null);
+					diffs.put(relPath, pDiff);
+				} else {
+					if (p.isMultiple())
+						continue props;
+					Value referenceValue = p.getValue();
+					Value newValue = observed.getProperty(name).getValue();
+					if (!referenceValue.equals(newValue)) {
+						String relPath = propertyRelPath(baseRelPath, name);
+						PropertyDiff pDiff = new PropertyDiff(
+								PropertyDiff.MODIFIED, relPath, referenceValue,
+								newValue);
+						diffs.put(relPath, pDiff);
+					}
+				}
+			}
+			// check added
+			pit = observed.getProperties();
+			props: while (pit.hasNext()) {
+				Property p = pit.nextProperty();
+				String name = p.getName();
+				if (name.startsWith("jcr:"))
+					continue props;
+				if (!reference.hasProperty(name)) {
+					String relPath = propertyRelPath(baseRelPath, name);
+					PropertyDiff pDiff = new PropertyDiff(PropertyDiff.ADDED,
+							relPath, null, p.getValue());
+					diffs.put(relPath, pDiff);
+				}
+			}
+		} catch (RepositoryException e) {
+			throw new ArgeoException("Cannot diff " + reference + " and "
+					+ observed, e);
+		}
+	}
+
+	/**
+	 * Compare only a restricted list of properties of two nodes. No
+	 * recursivity.
+	 * 
+	 */
+	public static Map<String, PropertyDiff> diffProperties(Node reference,
+			Node observed, List<String> properties) {
+		Map<String, PropertyDiff> diffs = new TreeMap<String, PropertyDiff>();
+		try {
+			Iterator<String> pit = properties.iterator();
+
+			props: while (pit.hasNext()) {
+				String name = pit.next();
+				if (!reference.hasProperty(name)) {
+					if (!observed.hasProperty(name))
+						continue props;
+					Value val = observed.getProperty(name).getValue();
+					try {
+						// empty String but not null
+						if ("".equals(val.getString()))
+							continue props;
+					} catch (Exception e) {
+						// not parseable as String, silent
+					}
+					PropertyDiff pDiff = new PropertyDiff(PropertyDiff.ADDED,
+							name, null, val);
+					diffs.put(name, pDiff);
+				} else if (!observed.hasProperty(name)) {
+					PropertyDiff pDiff = new PropertyDiff(PropertyDiff.REMOVED,
+							name, reference.getProperty(name).getValue(), null);
+					diffs.put(name, pDiff);
+				} else {
+					Value referenceValue = reference.getProperty(name)
+							.getValue();
+					Value newValue = observed.getProperty(name).getValue();
+					if (!referenceValue.equals(newValue)) {
+						PropertyDiff pDiff = new PropertyDiff(
+								PropertyDiff.MODIFIED, name, referenceValue,
+								newValue);
+						diffs.put(name, pDiff);
+					}
+				}
+			}
+		} catch (RepositoryException e) {
+			throw new ArgeoException("Cannot diff " + reference + " and "
+					+ observed, e);
+		}
+		return diffs;
+	}
+
+	/** Builds a property relPath to be used in the diff. */
+	private static String propertyRelPath(String baseRelPath,
+			String propertyName) {
+		if (baseRelPath == null)
+			return propertyName;
+		else
+			return baseRelPath + '/' + propertyName;
+	}
 }