Start line:  
End line:  

Snippet Preview

Snippet HTML Code

Stack Overflow Questions
Copyright 2005-2013 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;
 
 
 import java.util.List;
 
 import static org.kuali.rice.core.api.impex.xml.XmlConstants.*;
Parses org.kuali.rice.kew.rule.bo.RuleTemplateBos from XML.

Author(s):
Kuali Rice Team (rice.collab@kuali.org)
See also:
org.kuali.rice.kew.rule.bo.RuleTemplateBo
 
 public class RuleTemplateXmlParser {
 
     private static final org.apache.log4j.Logger LOG = org.apache.log4j.Logger.getLogger(RuleTemplateXmlParser.class);

    
By default make attributes defined without a <required> element
 
     private static final boolean DEFAULT_ATTRIBUTE_REQUIRED = true;
     private static final boolean DEFAULT_ATTRIBUTE_ACTIVE = true;

    
A dummy document type used in the default rule
 
     private static final String DUMMY_DOCUMENT_TYPE = "dummyDocumentType";

    
Used to set the display order of attributes encountered in parsing runs during the lifetime of this object
 
     private int templateAttributeCounter = 0;
 
 
         try {
             Document doc = XmlHelper.trimSAXXml(input);
             Element root = doc.getRootElement();
             return parseRuleTemplates(root);
         } catch (JDOMException e) {
             throw new XmlException("Parse error."e);
         } catch (SAXException e) {
             throw new XmlException("Parse error."e);
         } catch (ParserConfigurationException e) {
             throw new XmlException("Parse error."e);
         }
     }
 
     public List<RuleTemplateBoparseRuleTemplates(Element elementthrows XmlException {
         List<RuleTemplateBoruleTemplates = new ArrayList<RuleTemplateBo>();
 
         // iterate over any RULE_TEMPLATES elements
         Collection<ElementruleTemplatesElements = XmlHelper.findElements(element);
         Iterator ruleTemplatesIterator = ruleTemplatesElements.iterator();
         while (ruleTemplatesIterator.hasNext()) {
             Element ruleTemplatesElement = (ElementruleTemplatesIterator.next();
             Collection<ElementruleTemplateElements = XmlHelper.findElements(ruleTemplatesElement);
            for (Iterator iterator = ruleTemplateElements.iterator(); iterator.hasNext();) {
                ruleTemplates.add(parseRuleTemplate((Elementiterator.next(), ruleTemplates));
            }
        }
        return ruleTemplates;
    }
    private RuleTemplateBo parseRuleTemplate(Element elementList<RuleTemplateBoruleTemplatesthrows XmlException {
        String name = element.getChildText();
        String description = element.getChildText();
        Attribute allowOverwriteAttrib = element.getAttribute("allowOverwrite");
        boolean allowOverwrite = false;
        if (allowOverwriteAttrib != null) {
            allowOverwrite = Boolean.valueOf(allowOverwriteAttrib.getValue()).booleanValue();
        }
        if (org.apache.commons.lang.StringUtils.isEmpty(name)) {
            throw new XmlException("RuleTemplate must have a name");
        }
        if (org.apache.commons.lang.StringUtils.isEmpty(description)) {
            throw new XmlException("RuleTemplate must have a description");
        }
        // look up the rule template by name first
        RuleTemplateBo ruleTemplate = KEWServiceLocator.getRuleTemplateService().findByRuleTemplateName(name);
        if (ruleTemplate == null) {
            // if it does not exist create a new one
            ruleTemplate = new RuleTemplateBo();
        } else {
            // if it does exist, update it, only if allowOverwrite is set
            if (!allowOverwrite) {
                throw new RuntimeException("Attempting to overwrite template " + name + " without allowOverwrite set");
            }
            // the name should be equal if one was actually found
            assert(name.equals(ruleTemplate.getName())) : "Existing template definition name does not match incoming definition name";
        } 
        // overwrite simple properties
        ruleTemplate.setName(name);
        ruleTemplate.setDescription(description);
        // update the delegation template
        updateDelegationTemplate(elementruleTemplateruleTemplates);
        // update the attribute relationships
        updateRuleTemplateAttributes(elementruleTemplate);
        // save the rule template first so that the default/template rule that is generated
        // in the process of setting defaults is associated properly with this rule template
        KEWServiceLocator.getRuleTemplateService().save(ruleTemplate);
        // update the default options
        updateRuleTemplateDefaultOptions(elementruleTemplate);
        KEWServiceLocator.getRuleTemplateService().save(ruleTemplate);
        return ruleTemplate;
    }

    
Updates the rule template default options. Updates any existing options, removes any omitted ones.

Parameters:
ruleTemplateElement the rule template XML element
updatedRuleTemplate the RuleTemplate being updated
Throws:
org.kuali.rice.core.api.util.xml.XmlException
    /*
     <element name="description" type="c:LongStringType"/>
     <element name="fromDate" type="c:ShortStringType" minOccurs="0"/>
     <element name="toDate" type="c:ShortStringType" minOccurs="0"/>
     <element name="forceAction" type="boolean"/>
     <element name="active" type="boolean"/>
     <element name="defaultActionRequested" type="c:ShortStringType"/>
     <element name="supportsComplete" type="boolean" default="true"/>
     <element name="supportsApprove" type="boolean" default="true"/>
     <element name="supportsAcknowledge" type="boolean" default="true"/>
     <element name="supportsFYI" type="boolean" default="true"/>
    */
    protected void updateRuleTemplateDefaultOptions(Element ruleTemplateElementRuleTemplateBo updatedRuleTemplatethrows XmlException {
        Element defaultsElement = ruleTemplateElement.getChild();
        // update the rule defaults; this yields whether or not this is a delegation rule template
        boolean isDelegation = updateRuleDefaults(defaultsElementupdatedRuleTemplate);
        // update the rule template options
        updateRuleTemplateOptions(defaultsElementupdatedRuleTemplateisDelegation);
    }

    
Updates the rule template defaults options with those in the defaults element

Parameters:
defaultsElement the ruleDefaults element
updatedRuleTemplate the Rule Template being updated
    protected void updateRuleTemplateOptions(Element defaultsElementRuleTemplateBo updatedRuleTemplateboolean isDelegationthrows XmlException {
        // the possible defaults options
        // NOTE: the current implementation will remove any existing RuleTemplateOption records for any values which are null, i.e. not set in the incoming XML.
        // to pro-actively set default values for omitted options, simply set those values here, and records will be added if not present
        String defaultActionRequested = null;
        Boolean supportsComplete = null;
        Boolean supportsApprove = null;
        Boolean supportsAcknowledge = null;
        Boolean supportsFYI = null;
        
        // remove any RuleTemplateOptions the template may have but that we know we aren't going to update/reset
        // (not sure if this case even exists...does anything else set rule template options?)
        updatedRuleTemplate.removeNonDefaultOptions();
        
        // read in new settings
        if (defaultsElement != null) {
        	defaultActionRequested = defaultsElement.getChildText();
            supportsComplete = BooleanUtils.toBooleanObject(defaultsElement.getChildText());
            supportsApprove = BooleanUtils.toBooleanObject(defaultsElement.getChildText());
            supportsAcknowledge = BooleanUtils.toBooleanObject(defaultsElement.getChildText());
            supportsFYI = BooleanUtils.toBooleanObject(defaultsElement.getChildText());
        }
        if (!isDelegation) {
            // if this is not a delegation template, store the template options that govern rule action constraints
            // in the RuleTemplateOptions of the template
            // we have two options for this behavior:
            // 1) conditionally parse above, and then unconditionally set/unset the properties; this will have the effect of REMOVING
            //    any of these previously specified rule template options (and is arguably the right thing to do)
            // 2) unconditionally parse above, and then conditionally set/unset the properties; this will have the effect of PRESERVING
            //    the existing rule template options on this template if it is a delegation template (which of course will be overwritten
            //    by this very same code if they subsequently upload without the delegation flag)
            // This is a minor point, but the second implementation is chosen as it preserved the current behavior
            updateOrDeleteRuleTemplateOption(updatedRuleTemplate.defaultActionRequested);
            updateOrDeleteRuleTemplateOption(updatedRuleTemplate.supportsApprove);
            updateOrDeleteRuleTemplateOption(updatedRuleTemplate.supportsAcknowledge);
            updateOrDeleteRuleTemplateOption(updatedRuleTemplate.supportsFYI);
            updateOrDeleteRuleTemplateOption(updatedRuleTemplate.supportsComplete);
        }
    }
    
    
Updates the default/template rule options with those in the defaults element

Parameters:
defaultsElement the ruleDefaults element
updatedRuleTemplate the Rule Template being updated
Returns:
whether this is a delegation rule template
    protected boolean updateRuleDefaults(Element defaultsElementRuleTemplateBo updatedRuleTemplatethrows XmlException {
        // NOTE: implementation detail: in contrast with the other options, the delegate template, and the rule attributes,
        // we unconditionally blow away the default rule and re-create it (we don't update the existing one, if there is one)
        if (updatedRuleTemplate.getId() != null) {
            RuleBaseValues ruleDefaults = KEWServiceLocator.getRuleService().findDefaultRuleByRuleTemplateId(updatedRuleTemplate.getId());
            if (ruleDefaults != null) {
                List ruleDelegationDefaults = KEWServiceLocator.getRuleDelegationService().findByDelegateRuleId(ruleDefaults.getId());
                // delete the rule
                KEWServiceLocator.getRuleService().delete(ruleDefaults.getId());
                // delete the associated rule delegation defaults
                for (Iterator iterator = ruleDelegationDefaults.iterator(); iterator.hasNext();) {
                    RuleDelegationBo ruleDelegation = (RuleDelegationBoiterator.next();
                    KEWServiceLocator.getRuleDelegationService().delete(ruleDelegation.getRuleDelegationId());
                }
            }
        }
        boolean isDelegation = false;
        if (defaultsElement != null) {
            String delegationTypeCode = defaultsElement.getChildText();
            DelegationType delegationType = null;
            isDelegation = !org.apache.commons.lang.StringUtils.isEmpty(delegationTypeCode);
            String description = defaultsElement.getChildText();
            
            // would normally be validated via schema but might not be present if invoking RuleXmlParser directly
            if (description == null) {
                throw new XmlException("Description must be specified in rule defaults");
            }
            
            String fromDate = defaultsElement.getChildText();
            String toDate = defaultsElement.getChildText();
            // toBooleanObject ensures that if the value is null (not set) that the Boolean object will likewise be null (will not default to a value)
            Boolean forceAction = BooleanUtils.toBooleanObject(defaultsElement.getChildText());
            Boolean active = BooleanUtils.toBooleanObject(defaultsElement.getChildText());
            if (isDelegation) {
                delegationType = DelegationType.parseCode(delegationTypeCode);
                if (delegationType == null) {
                    throw new XmlException("Invalid delegation type '" + delegationType + "'." + "  Expected one of: "
                                            + ..getCode() + "," + ..getCode());
                }
            }
    
            // create our "default rule" which encapsulates the defaults for the rule
            RuleBaseValues ruleDefaults = new RuleBaseValues();
    
            // set simple values
            ruleDefaults.setRuleTemplate(updatedRuleTemplate);
            ruleDefaults.setDocTypeName();
            ruleDefaults.setTemplateRuleInd(.);
            ruleDefaults.setCurrentInd(.);
            ruleDefaults.setVersionNbr(new Integer(0));
            ruleDefaults.setDescription(description);
    
            // these are non-nullable fields, so default them if they were not set in the defaults section
            ruleDefaults.setForceAction(Boolean.valueOf(BooleanUtils.isTrue(forceAction)));
            ruleDefaults.setActive(Boolean.valueOf(BooleanUtils.isTrue(active)));
        
            if (ruleDefaults.getActivationDate() == null) {
                ruleDefaults.setActivationDate(new Timestamp(System.currentTimeMillis()));
            }
    
            ruleDefaults.setFromDateValue(formatDate("fromDate"fromDate));
            ruleDefaults.setToDateValue(formatDate("toDate"toDate));
            
            // ok, if this is a "Delegate Template", then we need to set this other RuleDelegation object which contains
            // some delegation-related info
            RuleDelegationBo ruleDelegationDefaults = null;
            if (isDelegation) {
                ruleDelegationDefaults = new RuleDelegationBo();
                ruleDelegationDefaults.setDelegationRule(ruleDefaults);
                ruleDelegationDefaults.setDelegationType(delegationType);
                ruleDelegationDefaults.setResponsibilityId(.);
            }
            // explicitly save the new rule delegation defaults and default rule
            KEWServiceLocator.getRuleTemplateService().saveRuleDefaults(ruleDelegationDefaultsruleDefaults);
        } else {
            // do nothing, rule defaults will be deleted if ruleDefaults element is omitted
        }
        
        return isDelegation;
    }


    
Updates or deletes a specified rule template option on the rule template

Parameters:
updatedRuleTemplate the RuleTemplate being updated
key the option key
value the option value
    protected void updateOrDeleteRuleTemplateOption(RuleTemplateBo updatedRuleTemplateString keyObject value) {
        if (value != null) {
            // if the option exists and the incoming value is non-null (it's set), update it
            RuleTemplateOptionBo option = updatedRuleTemplate.getRuleTemplateOption(key);
            if (option != null) {
                option.setValue(value.toString());
            } else {
                updatedRuleTemplate.getRuleTemplateOptions().add(new RuleTemplateOptionBo(keyvalue.toString()));
            }
        } else {
            // otherwise if the incoming value IS null (not set), then explicitly remove the entry (if it exists)
            Iterator<RuleTemplateOptionBooptions = updatedRuleTemplate.getRuleTemplateOptions().iterator();
            while (options.hasNext()) {
                RuleTemplateOptionBo opt = options.next();
                if (key.equals(opt.getCode())) {
                    options.remove();
                    break;
                }
            }
        }
    }

    
Updates the rule template delegation template with the one specified in the XML (if any)

Parameters:
ruleTemplateElement the XML ruleTemplate element
updatedRuleTemplate the rule template to update
parsedRuleTemplates the rule templates parsed in this parsing run
Throws:
org.kuali.rice.core.api.util.xml.XmlException if a delegation template was specified but could not be found
    protected void updateDelegationTemplate(Element ruleTemplateElementRuleTemplateBo updatedRuleTemplateList<RuleTemplateBoparsedRuleTemplatesthrows XmlException {
        String delegateTemplateName = ruleTemplateElement.getChildText();
        if (delegateTemplateName != null) {
            // if a delegateTemplate was set in the XML, then look it up and set it on the RuleTemplate object
            // first try looking up an existing delegateTemplate in the system
            RuleTemplateBo delegateTemplate = KEWServiceLocator.getRuleTemplateService().findByRuleTemplateName(delegateTemplateName);
            // if not found, try the list of templates currently parsed
            if (delegateTemplate == null) {
                for (RuleTemplateBo rtparsedRuleTemplates) {
                    if (delegateTemplateName.equalsIgnoreCase(rt.getName())) {
                        // set the expected next rule template id on the target delegateTemplate
                    	String ruleTemplateId = KEWServiceLocator.getRuleTemplateService().getNextRuleTemplateId();
                        rt.setId(ruleTemplateId);
                        delegateTemplate = rt;
                        break;
                    }
                }
            }
            if (delegateTemplate == null) {
                throw new XmlException("Cannot find delegation template " + delegateTemplateName);
            }
            updatedRuleTemplate.setDelegationTemplateId(delegateTemplate.getDelegationTemplateId());
            updatedRuleTemplate.setDelegationTemplate(delegateTemplate);           
        } else {
            // the previously referenced template is left in the system
        }
    }

    
Updates the attributes set on the RuleTemplate

Parameters:
ruleTemplateElement the XML ruleTemplate element
updatedRuleTemplate the RuleTemplate being updated
Throws:
org.kuali.rice.core.api.util.xml.XmlException if there was a problem parsing the rule template attributes
    protected void updateRuleTemplateAttributes(Element ruleTemplateElementRuleTemplateBo updatedRuleTemplatethrows XmlException {
        // add any newly defined rule template attributes to the rule template,
        // update the active and required flags of any existing ones.
        // if this is an update of an existing rule template, related attribute objects will be present in this rule template object,
        // otherwise none will be present (so they'll all be new)
        Element attributesElement = ruleTemplateElement.getChild();
        List<RuleTemplateAttributeBoincomingAttributes = new ArrayList<RuleTemplateAttributeBo>();
        if (attributesElement != null) {
            incomingAttributes.addAll(parseRuleTemplateAttributes(attributesElementupdatedRuleTemplate));
        }
        // inactivate all current attributes
        for (RuleTemplateAttributeBo currentRuleTemplateAttributeupdatedRuleTemplate.getRuleTemplateAttributes()) {
            String ruleAttributeName = (currentRuleTemplateAttribute.getRuleAttribute() != null) ? currentRuleTemplateAttribute.getRuleAttribute().getName() : "(null)";
            .debug("Inactivating rule template attribute with id " + currentRuleTemplateAttribute.getId() + " and rule attribute with name " + ruleAttributeName);
            currentRuleTemplateAttribute.setActive(.);
        }
        // NOTE: attributes are deactivated, not removed
        // add/update any new attributes
        for (RuleTemplateAttributeBo ruleTemplateAttributeincomingAttributes) {
            RuleTemplateAttributeBo potentialExistingTemplateAttribute = updatedRuleTemplate.getRuleTemplateAttribute(ruleTemplateAttribute);
            if (potentialExistingTemplateAttribute != null) {
                // template attribute exists on rule template already; update the options
                potentialExistingTemplateAttribute.setActive(ruleTemplateAttribute.getActive());
                potentialExistingTemplateAttribute.setRequired(ruleTemplateAttribute.getRequired());
            } else {
                // template attribute does not yet exist on template so add it
                updatedRuleTemplate.getRuleTemplateAttributes().add(ruleTemplateAttribute);
            }
        }
    }

    
Parses the RuleTemplateAttributes defined on the rule template element

Parameters:
attributesElement the jdom Element object for the Rule Template attributes
ruleTemplate the RuleTemplate object
Returns:
the RuleTemplateAttributes defined on the rule template element
Throws:
org.kuali.rice.core.api.util.xml.XmlException
    private List<RuleTemplateAttributeBoparseRuleTemplateAttributes(Element attributesElementRuleTemplateBo ruleTemplatethrows XmlException {
        List<RuleTemplateAttributeBoruleTemplateAttributes = new ArrayList<RuleTemplateAttributeBo>();
        Collection<ElementattributeElements = XmlHelper.findElements(attributesElement);
        for (Iterator iterator = attributeElements.iterator(); iterator.hasNext();) {
            ruleTemplateAttributes.add(parseRuleTemplateAttribute((Elementiterator.next(), ruleTemplate));
        }
        return ruleTemplateAttributes;
    }

    
Parses a rule template attribute

Parameters:
element the attribute XML element
ruleTemplate the ruleTemplate to update
Returns:
a parsed rule template attribute
Throws:
org.kuali.rice.core.api.util.xml.XmlException if the attribute does not exist
    private RuleTemplateAttributeBo parseRuleTemplateAttribute(Element elementRuleTemplateBo ruleTemplatethrows XmlException {
        String attributeName = element.getChildText();
        String requiredValue = element.getChildText();
        String activeValue = element.getChildText();
        if (org.apache.commons.lang.StringUtils.isEmpty(attributeName)) {
            throw new XmlException("Attribute name must be non-empty");
        }
        boolean required = ;
        if (requiredValue != null) {
            required = Boolean.parseBoolean(requiredValue);
        }
        boolean active = ;
        if (activeValue != null) {
            active = Boolean.parseBoolean(activeValue);
        }
        RuleAttribute ruleAttribute = KEWServiceLocator.getRuleAttributeService().findByName(attributeName);
        if (ruleAttribute == null) {
            throw new XmlException("Could not locate rule attribute for name '" + attributeName + "'");
        }
        RuleTemplateAttributeBo templateAttribute = new RuleTemplateAttributeBo();
        templateAttribute.setRuleAttribute(ruleAttribute);
        templateAttribute.setRuleAttributeId(ruleAttribute.getId());
        templateAttribute.setRuleTemplate(ruleTemplate);
        templateAttribute.setRequired(Boolean.valueOf(required));
        templateAttribute.setActive(Boolean.valueOf(active));
        templateAttribute.setDisplayOrder(new Integer(++));
        return templateAttribute;
    }
    
    public Timestamp formatDate(String dateLabelString dateStringthrows XmlException {
    	if (StringUtils.isBlank(dateString)) {
    		return null;
    	}
    	try {
    		return new Timestamp(RiceConstants.getDefaultDateFormat().parse(dateString).getTime());
    	} catch (ParseException e) {
    		throw new XmlException(dateLabel + " is not in the proper format.  Should have been: " + .);
    	}
    }
New to GrepCode? Check out our FAQ X