1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34 package info.magnolia.importexport;
35
36 import info.magnolia.cms.core.Content;
37 import info.magnolia.cms.core.HierarchyManager;
38 import info.magnolia.cms.core.ItemType;
39 import info.magnolia.cms.core.NodeData;
40 import info.magnolia.cms.util.ContentUtil;
41 import info.magnolia.cms.util.OrderedProperties;
42 import org.apache.commons.beanutils.ConvertUtils;
43 import org.apache.commons.lang.StringUtils;
44 import org.apache.jackrabbit.util.ISO8601;
45
46 import javax.jcr.PropertyType;
47 import javax.jcr.RepositoryException;
48 import javax.jcr.Value;
49
50 import java.io.ByteArrayInputStream;
51 import java.io.IOException;
52 import java.io.InputStream;
53 import java.util.Calendar;
54 import java.util.Collection;
55 import java.util.Properties;
56 import java.util.Set;
57
58
59
60
61
62
63
64
65
66
67 public class PropertiesImportExport {
68
69 public void createContent(Content root, InputStream propertiesStream) throws IOException, RepositoryException {
70 Properties properties = new OrderedProperties();
71
72 properties.load(propertiesStream);
73
74 properties = keysToInnerFormat(properties);
75
76 for (Object o : properties.keySet()) {
77 String key = (String) o;
78 String valueStr = properties.getProperty(key);
79
80 String propertyName = StringUtils.substringAfterLast(key, ".");
81 String path = StringUtils.substringBeforeLast(key, ".");
82
83 String type = null;
84 if (propertyName.equals("@type")) {
85 type = valueStr;
86 } else if (properties.containsKey(path + ".@type")) {
87 type = properties.getProperty(path + ".@type");
88 }
89
90 type = StringUtils.defaultIfEmpty(type, ItemType.CONTENTNODE.getSystemName());
91 Content c = ContentUtil.createPath(root, path, new ItemType(type));
92 populateContent(c, propertyName, valueStr);
93 }
94 }
95
96
97
98
99 private Properties keysToInnerFormat(Properties properties) {
100 Properties cleaned = new OrderedProperties();
101
102 for (Object o : properties.keySet()) {
103 String orgKey = (String) o;
104
105
106 String newKey = orgKey;
107
108
109 newKey = StringUtils.replace(newKey, "@", ".@");
110
111 newKey = StringUtils.replace(newKey, "..@", ".@");
112
113 String propertyName = StringUtils.substringAfterLast(newKey, ".");
114 String keySuffix = StringUtils.substringBeforeLast(newKey, ".");
115 String path = StringUtils.replace(keySuffix, ".", "/");
116 path = StringUtils.removeStart(path, "/");
117
118
119 if (StringUtils.isEmpty(propertyName)){
120
121 if(StringUtils.isEmpty(properties.getProperty(orgKey))) {
122
123 if(!properties.containsKey(orgKey + "@type")){
124 cleaned.put(path + ".@type", ItemType.CONTENTNODE.getSystemName());
125 }
126 continue;
127 }
128 propertyName = StringUtils.substringAfterLast(path, "/");
129 path = StringUtils.substringBeforeLast(path, "/");
130 }
131 cleaned.put(path + "." + propertyName, properties.get(orgKey));
132 }
133 return cleaned;
134 }
135
136 protected void populateContent(Content c, String name, String valueStr) throws RepositoryException {
137 if (StringUtils.isEmpty(name) && StringUtils.isEmpty(valueStr)) {
138
139 return;
140 }
141 if (name.equals("@type")) {
142
143 } else if (name.equals("@uuid")) {
144 throw new UnsupportedOperationException("Can't see UUIDs on real node. Use MockUtil if you are using MockContent instances.");
145 } else {
146 Object valueObj = convertNodeDataStringToObject(valueStr);
147 c.setNodeData(name, valueObj);
148 }
149 }
150
151 protected Object convertNodeDataStringToObject(String valueStr) {
152 if (contains(valueStr, ':')) {
153 final String type = StringUtils.substringBefore(valueStr, ":");
154 final String value = StringUtils.substringAfter(valueStr, ":");
155
156
157 if (type.equalsIgnoreCase("date")) {
158 return ISO8601.parse(value);
159 } else if (type.equalsIgnoreCase("binary")) {
160 return new ByteArrayInputStream(value.getBytes());
161 } else {
162 try {
163 final Class<?> typeCl;
164 if (type.equals("int")) {
165 typeCl = Integer.class;
166 } else {
167 typeCl = Class.forName("java.lang." + StringUtils.capitalize(type));
168 }
169 return ConvertUtils.convert(value, typeCl);
170 } catch (ClassNotFoundException e) {
171
172 return valueStr;
173 }
174 }
175 }
176
177 return valueStr;
178 }
179
180
181
182
183
184
185
186
187
188
189
190 @Deprecated
191 public static Properties toProperties(HierarchyManager hm) throws Exception {
192 return toProperties(hm.getRoot());
193 }
194
195
196
197
198 public static Properties toProperties(Content rootContent) throws Exception {
199 return toProperties(rootContent, ContentUtil.EXCLUDE_META_DATA_CONTENT_FILTER, true);
200 }
201
202
203
204
205 public static Properties contentToProperties(HierarchyManager hm) throws Exception {
206 return contentToProperties(hm.getRoot());
207 }
208
209
210
211
212 public static Properties contentToProperties(Content rootContent) throws Exception {
213 return toProperties(rootContent, ContentUtil.EXCLUDE_META_DATA_CONTENT_FILTER, false);
214 }
215
216
217
218
219 public static Properties contentToProperties(Content rootContent, Content.ContentFilter filter) throws Exception {
220 return toProperties(rootContent, filter, false);
221 }
222
223
224
225
226
227
228
229
230
231
232
233
234
235 private static Properties toProperties(Content rootContent, Content.ContentFilter contentFilter, final boolean legacyMode) throws Exception {
236 final Properties out = new OrderedProperties();
237 ContentUtil.visit(rootContent, new ContentUtil.Visitor() {
238 @Override
239 public void visit(Content node) throws Exception {
240 if (!legacyMode) {
241 appendNodeTypeAndUUID(node, out, true);
242 }
243 appendNodeProperties(node, out);
244 }
245 }, contentFilter);
246 return out;
247 }
248
249 private static void appendNodeTypeAndUUID(Content node, Properties out, final boolean dumpMetaData) throws RepositoryException {
250 String path = getExportPath(node);
251
252 if (path.equals("/jcr:root")) {
253 return;
254 }
255
256 String nodeTypeName = node.getNodeTypeName();
257 if (nodeTypeName != null && StringUtils.isNotEmpty(nodeTypeName)) {
258 out.put(path + "@type", nodeTypeName);
259 }
260 String nodeUUID = node.getUUID();
261 if (nodeUUID != null && StringUtils.isNotEmpty(nodeUUID)) {
262 out.put(path + "@uuid", node.getUUID());
263 }
264 }
265
266 public static void appendNodeProperties(Content node, Properties out) {
267 final Collection<NodeData> props = node.getNodeDataCollection();
268 for (NodeData prop : props) {
269 final String path = getExportPath(node) + "." + prop.getName();
270
271 String propertyValue = getPropertyString(prop);
272
273 if (propertyValue != null) {
274 out.setProperty(path, propertyValue);
275 }
276 }
277 }
278
279 private static String getExportPath(Content node) {
280 return node.getHandle();
281 }
282
283 private static String getPropertyString(NodeData prop) {
284 int propType = prop.getType();
285
286 switch (propType) {
287 case (PropertyType.STRING): {
288 return prop.getString();
289 }
290 case (PropertyType.BOOLEAN): {
291 return convertBooleanToExportString(prop.getBoolean());
292 }
293 case (PropertyType.BINARY): {
294 return convertBinaryToExportString(prop.getValue());
295 }
296 case (PropertyType.PATH): {
297 return prop.getString();
298 }
299 case (PropertyType.DATE): {
300 return convertCalendarToExportString(prop.getDate());
301 }
302 case (PropertyType.LONG): {
303 return "" + prop.getLong();
304 }
305 case (PropertyType.DOUBLE): {
306 return "" + prop.getDouble();
307 }
308 default: {
309 return prop.getString();
310 }
311 }
312 }
313
314 private static String convertBooleanToExportString(boolean b) {
315 return "boolean:" + (b ? "true" : "false");
316 }
317
318 private static String convertBinaryToExportString(Value value) {
319 return "binary:" + ConvertUtils.convert(value);
320 }
321
322 private static String convertCalendarToExportString(Calendar calendar) {
323 return "date:" + ISO8601.format(calendar);
324 }
325
326
327
328
329
330 public static String dumpPropertiesToString(Content content, Content.ContentFilter filter) throws Exception {
331 Properties properties = PropertiesImportExport.contentToProperties(content, filter);
332 return dumpPropertiesToString(properties);
333 }
334
335 public static String dumpPropertiesToString(Properties properties) {
336 final StringBuilder sb = new StringBuilder();
337 final Set<Object> propertyNames = properties.keySet();
338 for (Object propertyKey : propertyNames) {
339 final String name = propertyKey.toString();
340 final String value = properties.getProperty(name);
341 sb.append(name);
342 sb.append("=");
343 sb.append(value);
344 sb.append("\n");
345 }
346 return sb.toString();
347 }
348
349 private static boolean contains(String s, char ch) {
350 return s.indexOf(ch) > -1;
351 }
352 }