1
22
23 package com.liferay.portlet.workflow.jbi;
24
25 import com.liferay.portal.kernel.util.GetterUtil;
26 import com.liferay.portal.kernel.util.StringPool;
27 import com.liferay.portal.kernel.util.Validator;
28 import com.liferay.portal.util.PortalUtil;
29 import com.liferay.portlet.workflow.model.WorkflowDefinition;
30 import com.liferay.portlet.workflow.model.WorkflowInstance;
31 import com.liferay.portlet.workflow.model.WorkflowTask;
32 import com.liferay.portlet.workflow.model.WorkflowTaskFormElement;
33 import com.liferay.portlet.workflow.model.WorkflowToken;
34
35 import java.text.ParseException;
36 import java.text.SimpleDateFormat;
37
38 import java.util.ArrayList;
39 import java.util.Date;
40 import java.util.Iterator;
41 import java.util.LinkedHashMap;
42 import java.util.List;
43 import java.util.Map;
44
45 import org.apache.commons.logging.Log;
46 import org.apache.commons.logging.LogFactory;
47
48 import org.dom4j.Document;
49 import org.dom4j.DocumentException;
50 import org.dom4j.Element;
51
52
58 public class WorkflowXMLUtil {
59
60 public static Date parseDate(String date) throws ParseException {
61 if (Validator.isNull(date)) {
62 return null;
63 }
64
65 SimpleDateFormat sdf = new SimpleDateFormat("MM/dd/yyyy");
66
67 return GetterUtil.getDate(date, sdf);
68 }
69
70 public static Date parseDateTime(String date) throws ParseException {
71 if (Validator.isNull(date)) {
72 return null;
73 }
74
75 SimpleDateFormat sdf = new SimpleDateFormat("MM/dd/yyyy hh:mm:ss aaa");
76
77 return GetterUtil.getDate(date, sdf);
78 }
79
80 public static WorkflowDefinition parseDefinition(String xml)
81 throws DocumentException, ParseException {
82
83 Document doc = PortalUtil.readDocumentFromXML(xml);
84
85 Element root = doc.getRootElement();
86
87 return parseDefinition(root.element("definition"));
88 }
89
90 public static WorkflowDefinition parseDefinition(Element el) {
91 long definitionId = GetterUtil.getLong(
92 el.elementText("definitionId"));
93 String name = el.elementText("name");
94 String type = el.elementText("type");
95 double version = GetterUtil.getDouble(el.elementText("version"));
96
97 WorkflowDefinition definition = new WorkflowDefinition();
98
99 definition.setDefinitionId(definitionId);
100 definition.setName(name);
101 definition.setType(type);
102 definition.setVersion(version);
103
104 return definition;
105 }
106
107 public static List parseDefinitions(Element root) {
108 List definitions = new ArrayList();
109
110 Iterator itr = root.elements("definition").iterator();
111
112 while (itr.hasNext()) {
113 Element el = (Element)itr.next();
114
115 WorkflowDefinition definition = parseDefinition(el);
116
117 definitions.add(definition);
118 }
119
120 return definitions;
121 }
122
123 public static Map parseErrors(String xml) throws DocumentException {
124 Map errors = new LinkedHashMap();
125
126 Document doc = PortalUtil.readDocumentFromXML(xml);
127
128 Element root = doc.getRootElement();
129
130 Iterator itr = root.elements("error").iterator();
131
132 while (itr.hasNext()) {
133 Element el = (Element)itr.next();
134
135 String name = el.elementText("name");
136 String code = el.elementText("code");
137
138 errors.put(name, code);
139 }
140
141 return errors;
142 }
143
144 public static WorkflowInstance parseInstance(String xml)
145 throws DocumentException, ParseException {
146
147 Document doc = PortalUtil.readDocumentFromXML(xml);
148
149 Element root = doc.getRootElement();
150
151 return parseInstance(root.element("instance"));
152 }
153
154 public static WorkflowInstance parseInstance(Element el)
155 throws ParseException {
156
157 long instanceId = GetterUtil.getLong(el.elementText("instanceId"));
158 Date startDate = parseDateTime(el.elementText("startDate"));
159 Date endDate = parseDateTime(el.elementText("endDate"));
160 boolean ended = GetterUtil.getBoolean(el.elementText("ended"));
161
162 List definitions = parseDefinitions(el);
163
164 WorkflowDefinition definition =
165 (WorkflowDefinition)definitions.get(0);
166
167 List tokens = parseTokens(el);
168
169 WorkflowToken token = new WorkflowToken();
170
171 if (tokens.size() > 0) {
172 token = (WorkflowToken)tokens.get(0);
173 }
174
175 WorkflowInstance instance = new WorkflowInstance();
176
177 instance.setInstanceId(instanceId);
178 instance.setDefinition(definition);
179 instance.setStartDate(startDate);
180 instance.setEndDate(endDate);
181 instance.setToken(token);
182 instance.setEnded(ended);
183
184 return instance;
185 }
186
187 public static List parseInstances(Element root) throws ParseException {
188 List instances = new ArrayList();
189
190 Iterator itr = root.elements("instance").iterator();
191
192 while (itr.hasNext()) {
193 Element el = (Element)itr.next();
194
195 WorkflowInstance instance = parseInstance(el);
196
197 instances.add(instance);
198 }
199
200 return instances;
201 }
202
203 public static int parseInt(String xml, String name)
204 throws DocumentException {
205
206 return GetterUtil.getInteger(parseString(xml, name));
207 }
208
209 public static List parseList(String xml, String name)
210 throws DocumentException, ParseException {
211
212 Document doc = PortalUtil.readDocumentFromXML(xml);
213
214 Element root = doc.getRootElement();
215
216 if (name.equals("definitions")) {
217 return parseDefinitions(root);
218 }
219 else if (name.equals("instances")) {
220 return parseInstances(root);
221 }
222 else if (name.equals("taskFormElements")) {
223 return parseTaskFormElements(root);
224 }
225 else if (name.equals("tasks")) {
226 return parseTasks(root);
227 }
228 else if (name.equals("taskTransitions")) {
229 return parseTaskTransitions(root);
230 }
231 else if (name.equals("tokens")) {
232 return parseTokens(root);
233 }
234 else {
235 throw new DocumentException("List name " + name + " not valid");
236 }
237 }
238
239 public static String parseString(String xml, String name)
240 throws DocumentException {
241
242 try {
243 Document doc = PortalUtil.readDocumentFromXML(xml);
244
245 Element root = doc.getRootElement();
246
247 Element el = root.element(name);
248
249 if (el != null) {
250 return el.getText();
251 }
252 else {
253 return StringPool.BLANK;
254 }
255 }
256 catch (DocumentException de) {
257 _log.error("Error parsing " + name + " from:\n\n" + xml);
258
259 throw de;
260 }
261 }
262
263 public static List parseTaskFormElements(Element root) {
264 List taskFormElements = new ArrayList();
265
266 Iterator itr1 = root.elements("taskFormElement").iterator();
267
268 while (itr1.hasNext()) {
269 Element el = (Element)itr1.next();
270
271 String type = el.elementText("type");
272 String displayName = el.elementText("displayName");
273 String variableName = el.elementText("variableName");
274 String value = el.elementText("value");
275
276 List valueList = new ArrayList();
277
278 Iterator itr2 = el.element("values").elements("value").iterator();
279
280 while (itr2.hasNext()) {
281 Element valueEl = (Element)itr2.next();
282
283 valueList.add(valueEl.getText());
284 }
285
286 boolean readable = GetterUtil.getBoolean(
287 el.elementText("readable"));
288 boolean writable = GetterUtil.getBoolean(
289 el.elementText("writable"));
290 boolean required = GetterUtil.getBoolean(
291 el.elementText("required"));
292
293 WorkflowTaskFormElement taskFormElement =
294 new WorkflowTaskFormElement();
295
296 taskFormElement.setType(type);
297 taskFormElement.setDisplayName(displayName);
298 taskFormElement.setVariableName(variableName);
299 taskFormElement.setValue(value);
300 taskFormElement.setValueList(valueList);
301 taskFormElement.setReadable(readable);
302 taskFormElement.setWritable(writable);
303 taskFormElement.setRequired(required);
304
305 taskFormElements.add(taskFormElement);
306 }
307
308 return taskFormElements;
309 }
310
311 public static List parseTasks(Element root) throws ParseException {
312 List tasks = new ArrayList();
313
314 Iterator itr = root.elements("task").iterator();
315
316 while (itr.hasNext()) {
317 Element el = (Element)itr.next();
318
319 long taskId = GetterUtil.getLong(el.elementText("taskId"));
320
321 if (taskId == 0) {
322 break;
323 }
324
325 String name = el.elementText("name");
326 long assignedUserId = GetterUtil.getLong(
327 el.elementText("assignedUserId"));
328 Date createDate = parseDateTime(el.elementText("createDate"));
329 Date startDate = parseDateTime(el.elementText("startDate"));
330 Date endDate = parseDateTime(el.elementText("endDate"));
331
332 List instances = parseInstances(el);
333
334 WorkflowInstance instance = (WorkflowInstance)instances.get(0);
335
336 WorkflowTask task = new WorkflowTask();
337
338 task.setTaskId(taskId);
339 task.setName(name);
340 task.setInstance(instance);
341 task.setAssignedUserId(assignedUserId);
342 task.setCreateDate(createDate);
343 task.setStartDate(startDate);
344 task.setEndDate(endDate);
345
346 tasks.add(task);
347 }
348
349 return tasks;
350 }
351
352 public static List parseTaskTransitions(Element root) {
353 List taskTransitions = new ArrayList();
354
355 Iterator itr = root.elements("transition").iterator();
356
357 while (itr.hasNext()) {
358 Element el = (Element)itr.next();
359
360 String name = el.getText();
361
362 taskTransitions.add(name);
363 }
364
365 return taskTransitions;
366 }
367
368 public static List parseTokens(Element root) throws ParseException {
369 List tokens = new ArrayList();
370
371 Iterator itr = root.elements("token").iterator();
372
373 while (itr.hasNext()) {
374 Element el = (Element)itr.next();
375
376 long tokenId = GetterUtil.getLong(el.elementText("tokenId"));
377 String name = el.elementText("name");
378 String type = el.elementText("type");
379
380 List tasks = parseTasks(el);
381 List children = parseTokens(el);
382
383 WorkflowToken token = new WorkflowToken();
384
385 token.setTokenId(tokenId);
386 token.setName(name);
387 token.setType(type);
388 token.setTasks(tasks);
389 token.setChildren(children);
390
391 tokens.add(token);
392 }
393
394 return tokens;
395 }
396
397 private static Log _log = LogFactory.getLog(WorkflowXMLUtil.class);
398
399 }