1   /**
2    * Copyright (c) 2000-2008 Liferay, Inc. All rights reserved.
3    *
4    * Permission is hereby granted, free of charge, to any person obtaining a copy
5    * of this software and associated documentation files (the "Software"), to deal
6    * in the Software without restriction, including without limitation the rights
7    * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
8    * copies of the Software, and to permit persons to whom the Software is
9    * furnished to do so, subject to the following conditions:
10   *
11   * The above copyright notice and this permission notice shall be included in
12   * all copies or substantial portions of the Software.
13   *
14   * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
15   * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
16   * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
17   * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
18   * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
19   * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
20   * SOFTWARE.
21   */
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.DocumentUtil;
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  /**
53   * <a href="WorkflowXMLUtil.java.html"><b><i>View Source</i></b></a>
54   *
55   * @author Charles May
56   *
57   */
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 = DocumentUtil.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 = DocumentUtil.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 = DocumentUtil.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 = DocumentUtil.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 = DocumentUtil.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 WorkflowTask parseTask(String xml)
312         throws DocumentException, ParseException {
313 
314         Document doc = DocumentUtil.readDocumentFromXML(xml);
315 
316         Element root = doc.getRootElement();
317 
318         return parseTask(root.element("task"));
319     }
320 
321     public static WorkflowTask parseTask(Element el) throws ParseException {
322         WorkflowTask task = new WorkflowTask();
323 
324         long taskId = GetterUtil.getLong(el.elementText("taskId"));
325 
326         if (taskId == 0) {
327             return null;
328         }
329 
330         String name = el.elementText("name");
331         long assignedUserId = GetterUtil.getLong(
332             el.elementText("assignedUserId"));
333         Date createDate = parseDateTime(el.elementText("createDate"));
334         Date startDate = parseDateTime(el.elementText("startDate"));
335         Date endDate = parseDateTime(el.elementText("endDate"));
336 
337         List instances = parseInstances(el);
338 
339         WorkflowInstance instance = (WorkflowInstance)instances.get(0);
340 
341         task.setTaskId(taskId);
342         task.setName(name);
343         task.setInstance(instance);
344         task.setAssignedUserId(assignedUserId);
345         task.setCreateDate(createDate);
346         task.setStartDate(startDate);
347         task.setEndDate(endDate);
348 
349         return task;
350     }
351 
352     public static List parseTasks(Element root) throws ParseException {
353         List tasks = new ArrayList();
354 
355         Iterator itr = root.elements("task").iterator();
356 
357         while (itr.hasNext()) {
358             Element el = (Element)itr.next();
359 
360             WorkflowTask task = parseTask(el);
361 
362             if (task != null) {
363                 tasks.add(task);
364             }
365         }
366 
367         return tasks;
368     }
369 
370     public static List parseTaskTransitions(Element root) {
371         List taskTransitions = new ArrayList();
372 
373         Iterator itr = root.elements("transition").iterator();
374 
375         while (itr.hasNext()) {
376             Element el = (Element)itr.next();
377 
378             String name = el.getText();
379 
380             taskTransitions.add(name);
381         }
382 
383         return taskTransitions;
384     }
385 
386     public static List parseTokens(Element root) throws ParseException {
387         List tokens = new ArrayList();
388 
389         Iterator itr = root.elements("token").iterator();
390 
391         while (itr.hasNext()) {
392             Element el = (Element)itr.next();
393 
394             long tokenId = GetterUtil.getLong(el.elementText("tokenId"));
395             String name = el.elementText("name");
396             String type = el.elementText("type");
397 
398             List tasks = parseTasks(el);
399             List children = parseTokens(el);
400 
401             WorkflowToken token = new WorkflowToken();
402 
403             token.setTokenId(tokenId);
404             token.setName(name);
405             token.setType(type);
406             token.setTasks(tasks);
407             token.setChildren(children);
408 
409             tokens.add(token);
410         }
411 
412         return tokens;
413     }
414 
415     private static Log _log = LogFactory.getLog(WorkflowXMLUtil.class);
416 
417 }