Java tutorial
/** * This file Copyright (c) 2003-2012 Magnolia International * Ltd. (http://www.magnolia-cms.com). All rights reserved. * * * This file is dual-licensed under both the Magnolia * Network Agreement and the GNU General Public License. * You may elect to use one or the other of these licenses. * * This file is distributed in the hope that it will be * useful, but AS-IS and WITHOUT ANY WARRANTY; without even the * implied warranty of MERCHANTABILITY or FITNESS FOR A * PARTICULAR PURPOSE, TITLE, or NONINFRINGEMENT. * Redistribution, except as permitted by whichever of the GPL * or MNA you select, is prohibited. * * 1. For the GPL license (GPL), you can redistribute and/or * modify this file under the terms of the GNU General * Public License, Version 3, as published by the Free Software * Foundation. You should have received a copy of the GNU * General Public License, Version 3 along with this program; * if not, write to the Free Software Foundation, Inc., 51 * Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. * * 2. For the Magnolia Network Agreement (MNA), this file * and the accompanying materials are made available under the * terms of the MNA which accompanies this distribution, and * is available at http://www.magnolia-cms.com/mna.html * * Any modifications to this file must keep this entire header * intact. * */ package info.magnolia.jcr.util; import java.io.ByteArrayInputStream; import java.io.IOException; import java.io.InputStream; import java.util.Arrays; import java.util.Calendar; import java.util.Properties; import javax.jcr.Node; import javax.jcr.Property; import javax.jcr.PropertyIterator; import javax.jcr.PropertyType; import javax.jcr.RepositoryException; import javax.jcr.Value; import org.apache.commons.beanutils.ConvertUtils; import org.apache.commons.io.IOUtils; import org.apache.commons.lang.StringUtils; import org.apache.jackrabbit.util.ISO8601; import info.magnolia.cms.util.OrderedProperties; import info.magnolia.jcr.predicate.AbstractPredicate; /** * Utility class providing support for properties-like format to import/export jcr data. Useful when data regularly * needs to be bootstrapped, for instance, and the jcr xml format is too cumbersome to maintain. * * Caution: Binary data is represented as ByteArrayInputStream because of the lack of a proper javax.jcr.Binary implementation * * TODO : handle conflicts (already existing nodes, properties, what to do with existing properties if we don't create * new nodes, ...) */ public class PropertiesImportExport { /** * Each property is one item in the properties varargs passed in. */ public void createNodes(Node root, String... properties) throws IOException, RepositoryException { createNodes(root, IOUtils.toInputStream(StringUtils.join(Arrays.asList(properties), "\n"))); } /** * Each property or node in the stream has to be separated by the \n. */ public void createNodes(Node root, InputStream propertiesStream) throws IOException, RepositoryException { Properties properties = new OrderedProperties(); properties.load(propertiesStream); properties = keysToInnerFormat(properties); for (Object o : properties.keySet()) { String key = (String) o; String valueStr = properties.getProperty(key); String propertyName = StringUtils.substringAfterLast(key, "."); String path = StringUtils.substringBeforeLast(key, "."); String type = null; if (propertyName.equals("@type")) { type = valueStr; } else if (properties.containsKey(path + ".@type")) { type = properties.getProperty(path + ".@type"); } type = StringUtils.defaultIfEmpty(type, NodeTypes.ContentNode.NAME); Node c = NodeUtil.createPath(root, path, type); populateNode(c, propertyName, valueStr); } } /** * Transforms the keys to the following inner notation: <code>/some/path/node.prop</code> or * <code>/some/path/node.@type</code>. */ private Properties keysToInnerFormat(Properties properties) { Properties cleaned = new OrderedProperties(); for (Object o : properties.keySet()) { String orgKey = (String) o; // explicitly enforce certain syntax if (!orgKey.startsWith("/")) { throw new IllegalArgumentException("Missing trailing '/' for key: " + orgKey); } if (StringUtils.countMatches(orgKey, ".") > 1) { throw new IllegalArgumentException("Key must not contain more than one '.': " + orgKey); } if (orgKey.contains("@") && !orgKey.contains(".@")) { throw new IllegalArgumentException("Key containing '@' must be preceded by a '.': " + orgKey); } // if this is a node definition (no property) String newKey = orgKey; String propertyName = StringUtils.substringAfterLast(newKey, "."); String keySuffix = StringUtils.substringBeforeLast(newKey, "."); String path = StringUtils.removeStart(keySuffix, "/"); // if this is a path (no property) if (StringUtils.isEmpty(propertyName)) { // no value --> is a node if (StringUtils.isEmpty(properties.getProperty(orgKey))) { // make this the type property if not defined otherwise if (!properties.containsKey(orgKey + ".@type")) { cleaned.put(path + ".@type", NodeTypes.ContentNode.NAME); } continue; } throw new IllegalArgumentException( "Key for a path (everything without a '.' is considered to be a path) must not contain a value ('='): " + orgKey); } cleaned.put(path + "." + propertyName, properties.get(orgKey)); } return cleaned; } protected void populateNode(Node node, String name, String valueStr) throws RepositoryException { if (StringUtils.isEmpty(name) && StringUtils.isEmpty(valueStr)) { // happens if the input properties file just created a node with no properties return; } if (name.equals("@type")) { // do nothing, this has been taken into account when creating the node. } else if (name.equals("@uuid") || name.equals("uuid")) { setIdentifier(node, valueStr); } else { Object valueObj = convertPropertyStringToObject(valueStr); PropertyUtil.setProperty(node, name, valueObj); } } /** * Intentionally created this method to allow simple creation of subclasses actually setting the identifier (e.g. in * tests). */ protected void setIdentifier(Node ignoredNode, String ignoredString) { throw new UnsupportedOperationException("Can't see UUIDs on real node."); } protected Object convertPropertyStringToObject(String valueStr) { if (contains(valueStr, ':')) { final String type = StringUtils.substringBefore(valueStr, ":"); final String value = StringUtils.substringAfter(valueStr, ":"); // there is no beanUtils converter for Calendar if (type.equalsIgnoreCase("date")) { return ISO8601.parse(value); } else if (type.equalsIgnoreCase("binary")) { return new ByteArrayInputStream(value.getBytes()); } else { try { final Class<?> typeCl; if (type.equals("int")) { typeCl = Integer.class; } else { typeCl = Class.forName("java.lang." + StringUtils.capitalize(type)); } return ConvertUtils.convert(value, typeCl); } catch (ClassNotFoundException e) { // possibly a stray :, let's ignore it for now return valueStr; } } } // no type specified, we assume it's a string, no conversion return valueStr; } private static boolean contains(String s, char ch) { return s.indexOf(ch) > -1; } public Properties toProperties(Node node, final AbstractPredicate<Node> nodePredicate) throws RepositoryException { final Properties out = new OrderedProperties(); NodeUtil.visit(node, new NodeVisitor() { @Override public void visit(Node node) throws RepositoryException { appendNodeTypeAndIdentifier(node, out); appendNodeProperties(node, out); } }, nodePredicate); return out; } private void appendNodeTypeAndIdentifier(Node node, Properties out) throws RepositoryException { // we don't need to export the JCR root node. if (node.getDepth() == 0) { return; } String path = getExportPath(node); String nodeTypeName = node.getPrimaryNodeType().getName(); if (nodeTypeName != null && StringUtils.isNotEmpty(nodeTypeName)) { out.put(path + ".@type", nodeTypeName); } String nodeIdentifier = node.getIdentifier(); if (nodeIdentifier != null && StringUtils.isNotEmpty(nodeIdentifier)) { out.put(path + ".@uuid", nodeIdentifier); } } private void appendNodeProperties(Node node, Properties out) throws RepositoryException { PropertyIterator propertyIterator = node.getProperties(); while (propertyIterator.hasNext()) { Property property = propertyIterator.nextProperty(); String path = getExportPath(node) + "." + property.getName(); String propertyValue = getPropertyString(property); if (propertyValue != null) { out.setProperty(path, propertyValue); } } } private String getExportPath(Node node) throws RepositoryException { return node.getPath(); } private String getPropertyString(Property property) throws RepositoryException { switch (property.getType()) { case (PropertyType.STRING): { return property.getString(); } case (PropertyType.BOOLEAN): { return convertBooleanToExportString(property.getBoolean()); } case (PropertyType.BINARY): { return convertBinaryToExportString(property.getValue()); } case (PropertyType.PATH): { return property.getString(); } case (PropertyType.DATE): { return convertCalendarToExportString(property.getDate()); } case (PropertyType.LONG): { return "" + property.getLong(); } case (PropertyType.DOUBLE): { return "" + property.getDouble(); } default: { return property.getString(); } } } private String convertBooleanToExportString(boolean b) { return "boolean:" + (b ? "true" : "false"); } private String convertBinaryToExportString(Value value) throws RepositoryException { return "binary:" + ConvertUtils.convert(value.getString()); } private String convertCalendarToExportString(Calendar calendar) { return "date:" + ISO8601.format(calendar); } }