001/**
002 * Copyright 2005-2014 The Kuali Foundation
003 *
004 * Licensed under the Educational Community License, Version 2.0 (the "License");
005 * you may not use this file except in compliance with the License.
006 * You may obtain a copy of the License at
007 *
008 * http://www.opensource.org/licenses/ecl2.php
009 *
010 * Unless required by applicable law or agreed to in writing, software
011 * distributed under the License is distributed on an "AS IS" BASIS,
012 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
013 * See the License for the specific language governing permissions and
014 * limitations under the License.
015 */
016package org.kuali.rice.kew.routemodule;
017
018import java.io.BufferedInputStream;
019import java.io.ByteArrayInputStream;
020import java.io.IOException;
021import java.util.ArrayList;
022import java.util.Iterator;
023import java.util.List;
024
025import javax.xml.parsers.DocumentBuilder;
026import javax.xml.parsers.DocumentBuilderFactory;
027import javax.xml.parsers.ParserConfigurationException;
028
029import org.kuali.rice.core.api.delegation.DelegationType;
030import org.kuali.rice.kew.api.exception.ResourceUnavailableException;
031import org.kuali.rice.kew.api.exception.WorkflowException;
032import org.kuali.rice.kew.routeheader.DocumentRouteHeaderValue;
033import org.w3c.dom.Document;
034import org.w3c.dom.NamedNodeMap;
035import org.w3c.dom.Node;
036import org.w3c.dom.NodeList;
037import org.xml.sax.SAXException;
038
039
040/**
041 * @author Kuali Rice Team (rice.collab@kuali.org)
042 */
043public class TestRouteModuleXMLHelper {
044
045    /**
046     * 
047     */
048    public static String toXML(TestDocContent docContent) {
049        StringBuffer buffer = new StringBuffer();
050        buffer.append("<docContent>");
051        for (Iterator rlIt = docContent.getRouteLevels().iterator(); rlIt.hasNext();) {
052            TestRouteLevel routeLevel = (TestRouteLevel) rlIt.next();
053            buffer.append("<routeLevel priority=\"").append(routeLevel.getPriority()).append("\">");
054            for (Iterator respIt = routeLevel.getResponsibilities().iterator(); respIt.hasNext();) {
055                TestResponsibility responsibility = (TestResponsibility) respIt.next();
056                buffer.append("<responsibility actionRequested=\"").append(responsibility.getActionRequested()).append("\" priority=\"").append(responsibility.getPriority()).append("\">");
057                TestRecipient recipient = responsibility.getRecipient();
058                buffer.append("<recipient type=\"").append(recipient.getType()).append("\" id=\"").append(recipient.getId()).append("\"/>");
059                if (!responsibility.getDelegations().isEmpty()) {
060                    buffer.append("<delegations>");
061                }
062                for (Iterator delIt = responsibility.getDelegations().iterator(); delIt.hasNext();) {
063                    TestDelegation delegation = (TestDelegation) delIt.next();
064                    buffer.append("<delegation type=\"").append(delegation.getType().getCode()).append("\">");
065                    TestResponsibility delResp = delegation.getResponsibility();
066                    buffer.append("<delegateResponsibility>");
067                    TestRecipient delRecipient = delResp.getRecipient();
068                    buffer.append("<recipient type=\"").append(delRecipient.getType()).append("\" id=\"").append(delRecipient.getId()).append("\"/>");
069                    buffer.append("</delegateResponsibility>");
070                    buffer.append("</delegation>");
071                }
072                if (!responsibility.getDelegations().isEmpty()) {
073                    buffer.append("</delegations>");
074                }
075                buffer.append("</responsibility>");
076            }
077            buffer.append("</routeLevel>");
078        }
079        buffer.append("</docContent>");
080        return buffer.toString();
081    }
082    
083    public static TestRouteLevel parseCurrentRouteLevel(DocumentRouteHeaderValue routeHeader) throws ResourceUnavailableException, WorkflowException {
084        try {
085            DocumentBuilder builder = DocumentBuilderFactory.newInstance().newDocumentBuilder();
086            Document document = builder.parse(new BufferedInputStream(new ByteArrayInputStream(routeHeader.getDocContent().getBytes())));
087            NodeList nodes = document.getElementsByTagName(TestRouteModuleConstants.ROUTE_LEVEL_ELEMENT);
088            Node routeLevelNode = null;
089            Integer priority = null;
090            for (int index = 0; index < nodes.getLength(); index++) {
091                Node node = nodes.item(index);
092                NamedNodeMap nodeMap = node.getAttributes();
093                Node priorityNode = nodeMap.getNamedItem(TestRouteModuleConstants.PRIORITY_ATTRIBUTE);
094                try {
095                    priority = Integer.valueOf(priorityNode.getNodeValue());
096                } catch (NumberFormatException e) {
097                    throw new WorkflowException("Invalid route level priority '"+priorityNode.getNodeValue()+"'", e);
098                }
099                if (priorityNode != null && routeHeader.getDocRouteLevel().equals(priority)) {
100                    routeLevelNode = node;
101                    break;
102                }
103            }
104            if (routeLevelNode == null) {
105                return null;
106            }
107            TestRouteLevel routeLevel = new TestRouteLevel();
108            routeLevel.setPriority(priority.intValue());
109            List responsibilityNodes = new ArrayList();
110            NodeList rlNodes = routeLevelNode.getChildNodes();
111            for (int index = 0; index < rlNodes.getLength(); index++) {
112                Node node = rlNodes.item(index);
113                if (node.getNodeName().equals(TestRouteModuleConstants.RESPONSIBILITY_ELEMENT)) {
114                    responsibilityNodes.add(node);
115                }
116            }
117            routeLevel.setResponsibilities(parseResponsibilities(responsibilityNodes));
118            return routeLevel;
119        } catch (ParserConfigurationException e) {
120            throw new ResourceUnavailableException("Could not configure DOM parser for route level " + routeHeader.getDocRouteLevel());
121        } catch (IOException e) {
122            throw new ResourceUnavailableException("Could not parse XML doc content for route level " + routeHeader.getDocRouteLevel());
123        } catch (SAXException e) {
124            throw new ResourceUnavailableException("Could not parse XML doc content for route level " + routeHeader.getDocRouteLevel());
125        }
126    }
127    
128    private static List parseResponsibilities(List responsibilityNodes) throws WorkflowException {
129        List responsibilities = new ArrayList();
130        for (Iterator iterator = responsibilityNodes.iterator(); iterator.hasNext();) {
131            Node node = (Node) iterator.next();
132            responsibilities.add(parseResponsibility(node));
133        }
134        return responsibilities;
135    }
136    
137    private static TestResponsibility parseResponsibility(Node responsibilityNode) throws WorkflowException {
138        TestResponsibility responsibility = new TestResponsibility();
139        NamedNodeMap attributes = responsibilityNode.getAttributes();
140        Node actionRequestedNode = attributes.getNamedItem(TestRouteModuleConstants.ACTION_REQUESTED_ATTRIBUTE);
141        Node priorityNode = attributes.getNamedItem(TestRouteModuleConstants.PRIORITY_ATTRIBUTE);
142        responsibility.setActionRequested(actionRequestedNode.getNodeValue());
143        try {
144            responsibility.setPriority(Integer.parseInt(priorityNode.getNodeValue()));
145        } catch (NumberFormatException e) {
146            throw new WorkflowException("Invalid responsibility priority '"+priorityNode.getNodeValue()+"'", e);
147        }
148        NodeList childNodes = responsibilityNode.getChildNodes();
149        for (int index = 0; index < childNodes.getLength(); index++) {
150            Node node = childNodes.item(index);
151            if (node.getNodeName().equals(TestRouteModuleConstants.RECIPIENT_ELEMENT)) {
152                responsibility.setRecipient(parseRecipient(node));
153            } else if (node.getNodeName().equals(TestRouteModuleConstants.DELEGATIONS_ELEMENT)) {
154                responsibility.setDelegations(parseDelegations(node));
155            }
156        }
157        return responsibility;
158    }
159    
160    private static TestRecipient parseRecipient(Node recipientNode) {
161        TestRecipient recipient = new TestRecipient();
162        NamedNodeMap attributes = recipientNode.getAttributes();
163        recipient.setType(attributes.getNamedItem(TestRouteModuleConstants.TYPE_ATTRIBUTE).getNodeValue());
164        recipient.setId(attributes.getNamedItem(TestRouteModuleConstants.ID_ATTRIBUTE).getNodeValue());
165        return recipient;
166    }
167    
168    private static List parseDelegations(Node delegationsNode) {
169        List delegations = new ArrayList();
170        NodeList childNodes = delegationsNode.getChildNodes();
171        for (int index = 0; index < childNodes.getLength(); index++) {
172            Node node = childNodes.item(index);
173            if (node.getNodeName().equals(TestRouteModuleConstants.DELEGATION_ELEMENT)) {
174                delegations.add(parseDelegation(node));
175            }
176        }
177        return delegations;
178    }
179    
180    private static TestDelegation parseDelegation(Node delegationNode) {
181        TestDelegation delegation = new TestDelegation();
182        NamedNodeMap attributes = delegationNode.getAttributes();
183        delegation.setType(DelegationType.fromCode(attributes.getNamedItem(TestRouteModuleConstants.TYPE_ATTRIBUTE)
184                .getNodeValue()));
185        NodeList childNodes = delegationNode.getChildNodes();
186        for (int index = 0; index < childNodes.getLength(); index++) {
187            Node node = childNodes.item(index);
188            if (node.getNodeName().equals(TestRouteModuleConstants.DELEGATE_RESPONSIBILITY_ELEMENT)) {
189                delegation.setResponsibility(parseDelegateResponsibility(node));
190            }
191        }
192        return delegation;
193    }
194    
195    private static TestResponsibility parseDelegateResponsibility(Node delegateResponsibilityNode) {
196        TestResponsibility responsibility = new TestResponsibility();
197        NodeList childNodes = delegateResponsibilityNode.getChildNodes();
198        for (int index = 0; index < childNodes.getLength(); index++) {
199            Node node = childNodes.item(index);
200            if (node.getNodeName().equals(TestRouteModuleConstants.RECIPIENT_ELEMENT)) {
201                responsibility.setRecipient(parseRecipient(node));
202            }
203        }
204        return responsibility;
205    }
206    
207}