Coverage Report

Coverage Report - org.kuali.rice.kew.xml.export.RuleXmlExporter

Classes in this File

0/110

0/56

 /*
  * Copyright 2005-2007 The Kuali Foundation
  *
  *
  * Licensed under the Educational Community License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at
  *
  * http://www.opensource.org/licenses/ecl2.php
  *
  * Unless required by applicable law or agreed to in writing, software
  * distributed under the License is distributed on an "AS IS" BASIS,
  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
 package org.kuali.rice.kew.xml.export;
 
 import org.apache.commons.collections.CollectionUtils;
 import org.apache.commons.lang.StringUtils;
 import org.jdom.Element;
 import org.jdom.Namespace;
 import org.kuali.rice.core.api.exception.RiceRuntimeException;
 import org.kuali.rice.core.api.impex.ExportDataSet;
 import org.kuali.rice.core.api.util.xml.XmlRenderer;
 import org.kuali.rice.core.framework.impex.xml.XmlExporter;
 import org.kuali.rice.kew.export.KewExportDataSet;
 import org.kuali.rice.kew.rule.RuleBaseValues;
 import org.kuali.rice.kew.rule.RuleDelegation;
 import org.kuali.rice.kew.rule.RuleExtension;
 import org.kuali.rice.kew.rule.RuleExtensionValue;
 import org.kuali.rice.kew.rule.RuleResponsibility;
 import org.kuali.rice.kew.rule.bo.RuleTemplateAttribute;
 import org.kuali.rice.kew.rule.web.WebRuleUtils;
 import org.kuali.rice.kew.service.KEWServiceLocator;
 import org.kuali.rice.kim.api.group.Group;
 import org.kuali.rice.kim.api.identity.principal.Principal;
 
 import java.util.Collection;
 import java.util.HashSet;
 import java.util.Iterator;
 import java.util.List;
 import java.util.Set;
 
 import static org.kuali.rice.core.api.impex.xml.XmlConstants.*;
 
 /**
  * Exports rules to XML.
  *
  * @see RuleBaseValues
  *
  * @author Kuali Rice Team (rice.collab@kuali.org)
  */
 public class RuleXmlExporter implements XmlExporter {
 
     protected final org.apache.log4j.Logger LOG = org.apache.log4j.Logger.getLogger(getClass());
 
     private XmlRenderer renderer;
     
     public RuleXmlExporter(Namespace namespace) {
             this.renderer = new XmlRenderer(namespace);
     }
     
         @Override
         public boolean supportPrettyPrint() {
                 return true;
         }
 
     public Element export(ExportDataSet exportDataSet) {
             KewExportDataSet dataSet = KewExportDataSet.fromExportDataSet(exportDataSet);
         if (!dataSet.getRules().isEmpty()) {
             Element rootElement = renderer.renderElement(null, RULES);
             rootElement.setAttribute(SCHEMA_LOCATION_ATTR, RULE_SCHEMA_LOCATION, SCHEMA_NAMESPACE);
             for (Iterator iterator = dataSet.getRules().iterator(); iterator.hasNext();) {
                     RuleBaseValues rule = (RuleBaseValues) iterator.next();
                     exportRule(rootElement, rule);
                     //turn below on if need export delegates in rule exportation
 //                    if(rule.getDelegateRule().booleanValue()){        
 //                            exportRuleDelegations(rootElement, rule);
 //                    }
             }
             return rootElement;
         }
         return null;
     }
 
     public void exportRule(Element parent, RuleBaseValues rule) {
             Element ruleElement = renderer.renderElement(parent, RULE);
         if (rule.getName() != null) {
             renderer.renderTextElement(ruleElement, NAME, rule.getName());
         }
         renderer.renderTextElement(ruleElement, DOCUMENT_TYPE, rule.getDocTypeName());
         if (rule.getRuleTemplateName() != null) {
             renderer.renderTextElement(ruleElement, RULE_TEMPLATE, rule.getRuleTemplateName());
         }
         renderer.renderTextElement(ruleElement, DESCRIPTION, rule.getDescription());
         if(rule.getFromDateString() != null){
             renderer.renderTextElement(ruleElement, FROM_DATE, rule.getFromDateString());
         }
         if(rule.getToDateString() != null){
             renderer.renderTextElement(ruleElement, TO_DATE, rule.getToDateString());
         }
         if (rule.getRuleExpressionDef() != null) {
             Element expressionElement = renderer.renderTextElement(ruleElement, EXPRESSION, rule.getRuleExpressionDef().getExpression());
             if (rule.getRuleExpressionDef().getType() != null) {
                 expressionElement.setAttribute("type", rule.getRuleExpressionDef().getType());
             }
         }
         renderer.renderBooleanElement(ruleElement, FORCE_ACTION, rule.getForceAction(), false);
         
         if (CollectionUtils.isEmpty(rule.getRuleExtensions()) && 
                         /* field values is not empty */
                         !(rule.getFieldValues() == null || rule.getFieldValues().size() == 0)) {
                 // the rule is in the wrong state (as far as we are concerned).
                 // translate it
                 WebRuleUtils.translateResponsibilitiesForSave(rule);
                 WebRuleUtils.translateFieldValuesForSave(rule);
                 
                 // do our exports
                     exportRuleExtensions(ruleElement, rule.getRuleExtensions());
                 
                 // translate it back
                 WebRuleUtils.populateRuleMaintenanceFields(rule);
         } else { 
                 exportRuleExtensions(ruleElement, rule.getRuleExtensions());
         }
         
         // put responsibilities in a single collection 
         Set<RuleResponsibility> responsibilities = new HashSet<RuleResponsibility>();
         responsibilities.addAll(rule.getResponsibilities());
         responsibilities.addAll(rule.getPersonResponsibilities());
         responsibilities.addAll(rule.getGroupResponsibilities());
         responsibilities.addAll(rule.getRoleResponsibilities());
         
         exportResponsibilities(ruleElement, responsibilities);
     }
 
     private void exportRuleExtensions(Element parent, List ruleExtensions) {
         if (!ruleExtensions.isEmpty()) {
             Element extsElement = renderer.renderElement(parent, RULE_EXTENSIONS);
             for (Iterator iterator = ruleExtensions.iterator(); iterator.hasNext();) {
                 RuleExtension extension = (RuleExtension) iterator.next();
                 Element extElement = renderer.renderElement(extsElement, RULE_EXTENSION);
                 RuleTemplateAttribute attribute = extension.getRuleTemplateAttribute();
                 renderer.renderTextElement(extElement, ATTRIBUTE, attribute.getRuleAttribute().getName());
                 renderer.renderTextElement(extElement, RULE_TEMPLATE, attribute.getRuleTemplate().getName());
                 exportRuleExtensionValues(extElement, extension.getExtensionValues());
             }
         }
     }
 
     private void exportRuleExtensionValues(Element parent, List extensionValues) {
         if (!extensionValues.isEmpty()) {
             Element extValuesElement = renderer.renderElement(parent, RULE_EXTENSION_VALUES);
             for (Iterator iterator = extensionValues.iterator(); iterator.hasNext();) {
                 RuleExtensionValue extensionValue = (RuleExtensionValue) iterator.next();
                 Element extValueElement = renderer.renderElement(extValuesElement, RULE_EXTENSION_VALUE);
                 renderer.renderTextElement(extValueElement, KEY, extensionValue.getKey());
                 renderer.renderTextElement(extValueElement, VALUE, extensionValue.getValue());
             }
         }
     }
 
     private void exportResponsibilities(Element parent, Collection<? extends RuleResponsibility> responsibilities) {
         if (responsibilities != null && !responsibilities.isEmpty()) {
             Element responsibilitiesElement = renderer.renderElement(parent, RESPONSIBILITIES);
             for (RuleResponsibility ruleResponsibility : responsibilities) {
                 Element respElement = renderer.renderElement(responsibilitiesElement, RESPONSIBILITY);
                 renderer.renderTextElement(respElement, RESPONSIBILITY_ID, "" + ruleResponsibility.getResponsibilityId());
                 if (ruleResponsibility.isUsingWorkflowUser()) {
                                     renderer.renderTextElement(respElement, PRINCIPAL_NAME, ruleResponsibility.getPrincipal().getPrincipalName());
                                 } else if (ruleResponsibility.isUsingGroup()) {
                                         Group group = ruleResponsibility.getGroup();
                                     Element groupElement = renderer.renderTextElement(respElement, GROUP_NAME, group.getName());
                                     groupElement.setAttribute(NAMESPACE, group.getNamespaceCode());
                                 } else if (ruleResponsibility.isUsingRole()) {
                                     renderer.renderTextElement(respElement, ROLE, ruleResponsibility.getRuleResponsibilityName());
                                     renderer.renderTextElement(respElement, APPROVE_POLICY, ruleResponsibility.getApprovePolicy());
                                 }
                 if (!StringUtils.isBlank(ruleResponsibility.getActionRequestedCd())) {
                         renderer.renderTextElement(respElement, ACTION_REQUESTED, ruleResponsibility.getActionRequestedCd());
                 }
                 if (ruleResponsibility.getPriority() != null) {
                         renderer.renderTextElement(respElement, PRIORITY, ruleResponsibility.getPriority().toString());
                 }
             }
         }
     }
     
     //below are for exporting rule delegations in rule exportation
     private void exportRuleDelegations(Element rootElement, RuleBaseValues rule){
                 List<RuleDelegation> ruleDelegationDefaults = KEWServiceLocator.getRuleDelegationService().findByDelegateRuleId(rule.getRuleBaseValuesId());
                 for(RuleDelegation dele : ruleDelegationDefaults){
                         if (LOG.isInfoEnabled()) {
                                 LOG.info("*******delegates********\t"  +  dele.getRuleDelegationId()) ;
                         }
                         exportRuleDelegation(rootElement, dele);        
                 }
     }
     
     private void exportRuleDelegation(Element parent, RuleDelegation ruleDelegation) {
             Element ruleDelegationElement = renderer.renderElement(parent, RULE_DELEGATION);
             exportRuleDelegationParentResponsibility(ruleDelegationElement, ruleDelegation);
             renderer.renderTextElement(ruleDelegationElement, DELEGATION_TYPE, ruleDelegation.getDelegationType());
             exportRule(ruleDelegationElement, ruleDelegation.getDelegationRuleBaseValues());
     }
     
     private void exportRuleDelegationParentResponsibility(Element parent, RuleDelegation delegation) {
         Element parentResponsibilityElement = renderer.renderElement(parent, PARENT_RESPONSIBILITY);
         RuleResponsibility ruleResponsibility = KEWServiceLocator.getRuleService().findRuleResponsibility(delegation.getResponsibilityId());
         renderer.renderTextElement(parentResponsibilityElement, PARENT_RULE_NAME, ruleResponsibility.getRuleBaseValues().getName());
         if (ruleResponsibility.isUsingWorkflowUser()) {
                 Principal principal = ruleResponsibility.getPrincipal();
                 renderer.renderTextElement(parentResponsibilityElement, PRINCIPAL_NAME, principal.getPrincipalName());
         } else if (ruleResponsibility.isUsingGroup()) {
                 Group group = ruleResponsibility.getGroup();
                 Element groupElement = renderer.renderElement(parentResponsibilityElement, GROUP_NAME);
                 groupElement.setText(group.getName());
                 groupElement.setAttribute(NAMESPACE, group.getNamespaceCode());
         } else if (ruleResponsibility.isUsingRole()) {
                 renderer.renderTextElement(parentResponsibilityElement, ROLE, ruleResponsibility.getRuleResponsibilityName());
         } else {
                 throw new RiceRuntimeException("Encountered a rule responsibility when exporting with an invalid type of '" + ruleResponsibility.getRuleResponsibilityType());
         }
     }
 
 }

1		/*
2		* Copyright 2005-2007 The Kuali Foundation
3		*
4		*
5		* Licensed under the Educational Community License, Version 2.0 (the "License");
6		* you may not use this file except in compliance with the License.
7		* You may obtain a copy of the License at
8		*
9		* http://www.opensource.org/licenses/ecl2.php
10		*
11		* Unless required by applicable law or agreed to in writing, software
12		* distributed under the License is distributed on an "AS IS" BASIS,
13		* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
14		* See the License for the specific language governing permissions and
15		* limitations under the License.
16		*/
17		package org.kuali.rice.kew.xml.export;
18
19		import org.apache.commons.collections.CollectionUtils;
20		import org.apache.commons.lang.StringUtils;
21		import org.jdom.Element;
22		import org.jdom.Namespace;
23		import org.kuali.rice.core.api.exception.RiceRuntimeException;
24		import org.kuali.rice.core.api.impex.ExportDataSet;
25		import org.kuali.rice.core.api.util.xml.XmlRenderer;
26		import org.kuali.rice.core.framework.impex.xml.XmlExporter;
27		import org.kuali.rice.kew.export.KewExportDataSet;
28		import org.kuali.rice.kew.rule.RuleBaseValues;
29		import org.kuali.rice.kew.rule.RuleDelegation;
30		import org.kuali.rice.kew.rule.RuleExtension;
31		import org.kuali.rice.kew.rule.RuleExtensionValue;
32		import org.kuali.rice.kew.rule.RuleResponsibility;
33		import org.kuali.rice.kew.rule.bo.RuleTemplateAttribute;
34		import org.kuali.rice.kew.rule.web.WebRuleUtils;
35		import org.kuali.rice.kew.service.KEWServiceLocator;
36		import org.kuali.rice.kim.api.group.Group;
37		import org.kuali.rice.kim.api.identity.principal.Principal;
38
39		import java.util.Collection;
40		import java.util.HashSet;
41		import java.util.Iterator;
42		import java.util.List;
43		import java.util.Set;
44
45		import static org.kuali.rice.core.api.impex.xml.XmlConstants.*;
46
47		/**
48		* Exports rules to XML.
49		*
50		* @see RuleBaseValues
51		*
52		* @author Kuali Rice Team (rice.collab@kuali.org)
53		*/
54		public class RuleXmlExporter implements XmlExporter {
55
56	0	protected final org.apache.log4j.Logger LOG = org.apache.log4j.Logger.getLogger(getClass());
57
58		private XmlRenderer renderer;
59
60	0	public RuleXmlExporter(Namespace namespace) {
61	0	this.renderer = new XmlRenderer(namespace);
62	0	}
63
64		@Override
65		public boolean supportPrettyPrint() {
66	0	return true;
67		}
68
69		public Element export(ExportDataSet exportDataSet) {
70	0	KewExportDataSet dataSet = KewExportDataSet.fromExportDataSet(exportDataSet);
71	0	if (!dataSet.getRules().isEmpty()) {
72	0	Element rootElement = renderer.renderElement(null, RULES);
73	0	rootElement.setAttribute(SCHEMA_LOCATION_ATTR, RULE_SCHEMA_LOCATION, SCHEMA_NAMESPACE);
74	0	for (Iterator iterator = dataSet.getRules().iterator(); iterator.hasNext();) {
75	0	RuleBaseValues rule = (RuleBaseValues) iterator.next();
76	0	exportRule(rootElement, rule);
77		//turn below on if need export delegates in rule exportation
78		// if(rule.getDelegateRule().booleanValue()){
79		// exportRuleDelegations(rootElement, rule);
80		// }
81	0	}
82	0	return rootElement;
83		}
84	0	return null;
85		}
86
87		public void exportRule(Element parent, RuleBaseValues rule) {
88	0	Element ruleElement = renderer.renderElement(parent, RULE);
89	0	if (rule.getName() != null) {
90	0	renderer.renderTextElement(ruleElement, NAME, rule.getName());
91		}
92	0	renderer.renderTextElement(ruleElement, DOCUMENT_TYPE, rule.getDocTypeName());
93	0	if (rule.getRuleTemplateName() != null) {
94	0	renderer.renderTextElement(ruleElement, RULE_TEMPLATE, rule.getRuleTemplateName());
95		}
96	0	renderer.renderTextElement(ruleElement, DESCRIPTION, rule.getDescription());
97	0	if(rule.getFromDateString() != null){
98	0	renderer.renderTextElement(ruleElement, FROM_DATE, rule.getFromDateString());
99		}
100	0	if(rule.getToDateString() != null){
101	0	renderer.renderTextElement(ruleElement, TO_DATE, rule.getToDateString());
102		}
103	0	if (rule.getRuleExpressionDef() != null) {
104	0	Element expressionElement = renderer.renderTextElement(ruleElement, EXPRESSION, rule.getRuleExpressionDef().getExpression());
105	0	if (rule.getRuleExpressionDef().getType() != null) {
106	0	expressionElement.setAttribute("type", rule.getRuleExpressionDef().getType());
107		}
108		}
109	0	renderer.renderBooleanElement(ruleElement, FORCE_ACTION, rule.getForceAction(), false);
110
111	0	if (CollectionUtils.isEmpty(rule.getRuleExtensions()) &&
112		/* field values is not empty */
113		!(rule.getFieldValues() == null \|\| rule.getFieldValues().size() == 0)) {
114		// the rule is in the wrong state (as far as we are concerned).
115		// translate it
116	0	WebRuleUtils.translateResponsibilitiesForSave(rule);
117	0	WebRuleUtils.translateFieldValuesForSave(rule);
118
119		// do our exports
120	0	exportRuleExtensions(ruleElement, rule.getRuleExtensions());
121
122		// translate it back
123	0	WebRuleUtils.populateRuleMaintenanceFields(rule);
124		} else {
125	0	exportRuleExtensions(ruleElement, rule.getRuleExtensions());
126		}
127
128		// put responsibilities in a single collection
129	0	Set<RuleResponsibility> responsibilities = new HashSet<RuleResponsibility>();
130	0	responsibilities.addAll(rule.getResponsibilities());
131	0	responsibilities.addAll(rule.getPersonResponsibilities());
132	0	responsibilities.addAll(rule.getGroupResponsibilities());
133	0	responsibilities.addAll(rule.getRoleResponsibilities());
134
135	0	exportResponsibilities(ruleElement, responsibilities);
136	0	}
137
138		private void exportRuleExtensions(Element parent, List ruleExtensions) {
139	0	if (!ruleExtensions.isEmpty()) {
140	0	Element extsElement = renderer.renderElement(parent, RULE_EXTENSIONS);
141	0	for (Iterator iterator = ruleExtensions.iterator(); iterator.hasNext();) {
142	0	RuleExtension extension = (RuleExtension) iterator.next();
143	0	Element extElement = renderer.renderElement(extsElement, RULE_EXTENSION);
144	0	RuleTemplateAttribute attribute = extension.getRuleTemplateAttribute();
145	0	renderer.renderTextElement(extElement, ATTRIBUTE, attribute.getRuleAttribute().getName());
146	0	renderer.renderTextElement(extElement, RULE_TEMPLATE, attribute.getRuleTemplate().getName());
147	0	exportRuleExtensionValues(extElement, extension.getExtensionValues());
148	0	}
149		}
150	0	}
151
152		private void exportRuleExtensionValues(Element parent, List extensionValues) {
153	0	if (!extensionValues.isEmpty()) {
154	0	Element extValuesElement = renderer.renderElement(parent, RULE_EXTENSION_VALUES);
155	0	for (Iterator iterator = extensionValues.iterator(); iterator.hasNext();) {
156	0	RuleExtensionValue extensionValue = (RuleExtensionValue) iterator.next();
157	0	Element extValueElement = renderer.renderElement(extValuesElement, RULE_EXTENSION_VALUE);
158	0	renderer.renderTextElement(extValueElement, KEY, extensionValue.getKey());
159	0	renderer.renderTextElement(extValueElement, VALUE, extensionValue.getValue());
160	0	}
161		}
162	0	}
163
164		private void exportResponsibilities(Element parent, Collection<? extends RuleResponsibility> responsibilities) {
165	0	if (responsibilities != null && !responsibilities.isEmpty()) {
166	0	Element responsibilitiesElement = renderer.renderElement(parent, RESPONSIBILITIES);
167	0	for (RuleResponsibility ruleResponsibility : responsibilities) {
168	0	Element respElement = renderer.renderElement(responsibilitiesElement, RESPONSIBILITY);
169	0	renderer.renderTextElement(respElement, RESPONSIBILITY_ID, "" + ruleResponsibility.getResponsibilityId());
170	0	if (ruleResponsibility.isUsingWorkflowUser()) {
171	0	renderer.renderTextElement(respElement, PRINCIPAL_NAME, ruleResponsibility.getPrincipal().getPrincipalName());
172	0	} else if (ruleResponsibility.isUsingGroup()) {
173	0	Group group = ruleResponsibility.getGroup();
174	0	Element groupElement = renderer.renderTextElement(respElement, GROUP_NAME, group.getName());
175	0	groupElement.setAttribute(NAMESPACE, group.getNamespaceCode());
176	0	} else if (ruleResponsibility.isUsingRole()) {
177	0	renderer.renderTextElement(respElement, ROLE, ruleResponsibility.getRuleResponsibilityName());
178	0	renderer.renderTextElement(respElement, APPROVE_POLICY, ruleResponsibility.getApprovePolicy());
179		}
180	0	if (!StringUtils.isBlank(ruleResponsibility.getActionRequestedCd())) {
181	0	renderer.renderTextElement(respElement, ACTION_REQUESTED, ruleResponsibility.getActionRequestedCd());
182		}
183	0	if (ruleResponsibility.getPriority() != null) {
184	0	renderer.renderTextElement(respElement, PRIORITY, ruleResponsibility.getPriority().toString());
185		}
186	0	}
187		}
188	0	}
189
190		//below are for exporting rule delegations in rule exportation
191		private void exportRuleDelegations(Element rootElement, RuleBaseValues rule){
192	0	List<RuleDelegation> ruleDelegationDefaults = KEWServiceLocator.getRuleDelegationService().findByDelegateRuleId(rule.getRuleBaseValuesId());
193	0	for(RuleDelegation dele : ruleDelegationDefaults){
194	0	if (LOG.isInfoEnabled()) {
195	0	LOG.info("*****delegates******\t" + dele.getRuleDelegationId()) ;
196		}
197	0	exportRuleDelegation(rootElement, dele);
198		}
199	0	}
200
201		private void exportRuleDelegation(Element parent, RuleDelegation ruleDelegation) {
202	0	Element ruleDelegationElement = renderer.renderElement(parent, RULE_DELEGATION);
203	0	exportRuleDelegationParentResponsibility(ruleDelegationElement, ruleDelegation);
204	0	renderer.renderTextElement(ruleDelegationElement, DELEGATION_TYPE, ruleDelegation.getDelegationType());
205	0	exportRule(ruleDelegationElement, ruleDelegation.getDelegationRuleBaseValues());
206	0	}
207
208		private void exportRuleDelegationParentResponsibility(Element parent, RuleDelegation delegation) {
209	0	Element parentResponsibilityElement = renderer.renderElement(parent, PARENT_RESPONSIBILITY);
210	0	RuleResponsibility ruleResponsibility = KEWServiceLocator.getRuleService().findRuleResponsibility(delegation.getResponsibilityId());
211	0	renderer.renderTextElement(parentResponsibilityElement, PARENT_RULE_NAME, ruleResponsibility.getRuleBaseValues().getName());
212	0	if (ruleResponsibility.isUsingWorkflowUser()) {
213	0	Principal principal = ruleResponsibility.getPrincipal();
214	0	renderer.renderTextElement(parentResponsibilityElement, PRINCIPAL_NAME, principal.getPrincipalName());
215	0	} else if (ruleResponsibility.isUsingGroup()) {
216	0	Group group = ruleResponsibility.getGroup();
217	0	Element groupElement = renderer.renderElement(parentResponsibilityElement, GROUP_NAME);
218	0	groupElement.setText(group.getName());
219	0	groupElement.setAttribute(NAMESPACE, group.getNamespaceCode());
220	0	} else if (ruleResponsibility.isUsingRole()) {
221	0	renderer.renderTextElement(parentResponsibilityElement, ROLE, ruleResponsibility.getRuleResponsibilityName());
222		} else {
223	0	throw new RiceRuntimeException("Encountered a rule responsibility when exporting with an invalid type of '" + ruleResponsibility.getRuleResponsibilityType());
224		}
225	0	}
226
227		}