001/**
002 * Copyright 2005-2015 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.xml;
017
018import org.apache.commons.lang.BooleanUtils;
019import org.apache.commons.lang.StringUtils;
020import org.jdom.Attribute;
021import org.jdom.Document;
022import org.jdom.Element;
023import org.jdom.JDOMException;
024import org.kuali.rice.core.api.delegation.DelegationType;
025import org.kuali.rice.core.api.util.RiceConstants;
026import org.kuali.rice.core.api.util.xml.XmlException;
027import org.kuali.rice.core.api.util.xml.XmlHelper;
028import org.kuali.rice.kew.rule.RuleBaseValues;
029import org.kuali.rice.kew.rule.RuleDelegationBo;
030import org.kuali.rice.kew.rule.RuleTemplateOptionBo;
031import org.kuali.rice.kew.rule.bo.RuleAttribute;
032import org.kuali.rice.kew.rule.bo.RuleTemplateBo;
033import org.kuali.rice.kew.rule.bo.RuleTemplateAttributeBo;
034import org.kuali.rice.kew.service.KEWServiceLocator;
035import org.kuali.rice.kew.api.KewApiConstants;
036import org.xml.sax.SAXException;
037
038import javax.xml.parsers.ParserConfigurationException;
039import java.io.IOException;
040import java.io.InputStream;
041import java.sql.Timestamp;
042import java.text.ParseException;
043import java.util.ArrayList;
044import java.util.Collection;
045import java.util.Iterator;
046import java.util.List;
047
048import static org.kuali.rice.core.api.impex.xml.XmlConstants.*;
049/**
050 * Parses {@link org.kuali.rice.kew.rule.bo.RuleTemplateBo}s from XML.
051 *
052 * @see org.kuali.rice.kew.rule.bo.RuleTemplateBo
053 *
054 * @author Kuali Rice Team (rice.collab@kuali.org)
055 */
056public class RuleTemplateXmlParser {
057
058    private static final org.apache.log4j.Logger LOG = org.apache.log4j.Logger.getLogger(RuleTemplateXmlParser.class);
059
060    /**
061     * By default make attributes defined without a <required> element
062     */
063    private static final boolean DEFAULT_ATTRIBUTE_REQUIRED = true;
064    private static final boolean DEFAULT_ATTRIBUTE_ACTIVE = true;
065
066    /**
067     * A dummy document type used in the default rule
068     */
069    private static final String DUMMY_DOCUMENT_TYPE = "dummyDocumentType";
070
071    /**
072     * Used to set the display order of attributes encountered in parsing runs during the lifetime of this object
073     */
074    private int templateAttributeCounter = 0;
075
076    public List<RuleTemplateBo> parseRuleTemplates(InputStream input) throws IOException, XmlException {
077
078        try {
079            Document doc = XmlHelper.trimSAXXml(input);
080            Element root = doc.getRootElement();
081            return parseRuleTemplates(root);
082        } catch (JDOMException e) {
083            throw new XmlException("Parse error.", e);
084        } catch (SAXException e) {
085            throw new XmlException("Parse error.", e);
086        } catch (ParserConfigurationException e) {
087            throw new XmlException("Parse error.", e);
088        }
089    }
090
091    public List<RuleTemplateBo> parseRuleTemplates(Element element) throws XmlException {
092        List<RuleTemplateBo> ruleTemplates = new ArrayList<RuleTemplateBo>();
093
094        // iterate over any RULE_TEMPLATES elements
095        Collection<Element> ruleTemplatesElements = XmlHelper.findElements(element, RULE_TEMPLATES);
096        Iterator ruleTemplatesIterator = ruleTemplatesElements.iterator();
097        while (ruleTemplatesIterator.hasNext()) {
098            Element ruleTemplatesElement = (Element) ruleTemplatesIterator.next();
099            Collection<Element> ruleTemplateElements = XmlHelper.findElements(ruleTemplatesElement, RULE_TEMPLATE);
100            for (Iterator iterator = ruleTemplateElements.iterator(); iterator.hasNext();) {
101                ruleTemplates.add(parseRuleTemplate((Element) iterator.next(), ruleTemplates));
102            }
103        }
104        return ruleTemplates;
105    }
106
107    private RuleTemplateBo parseRuleTemplate(Element element, List<RuleTemplateBo> ruleTemplates) throws XmlException {
108        String name = element.getChildText(NAME, RULE_TEMPLATE_NAMESPACE);
109        String description = element.getChildText(DESCRIPTION, RULE_TEMPLATE_NAMESPACE);
110        Attribute allowOverwriteAttrib = element.getAttribute("allowOverwrite");
111
112        boolean allowOverwrite = false;
113        if (allowOverwriteAttrib != null) {
114            allowOverwrite = Boolean.valueOf(allowOverwriteAttrib.getValue()).booleanValue();
115        }
116        if (org.apache.commons.lang.StringUtils.isEmpty(name)) {
117            throw new XmlException("RuleTemplate must have a name");
118        }
119        if (org.apache.commons.lang.StringUtils.isEmpty(description)) {
120            throw new XmlException("RuleTemplate must have a description");
121        }
122
123        // look up the rule template by name first
124        RuleTemplateBo ruleTemplate = KEWServiceLocator.getRuleTemplateService().findByRuleTemplateName(name);
125
126        if (ruleTemplate == null) {
127            // if it does not exist create a new one
128            ruleTemplate = new RuleTemplateBo();
129        } else {
130            // if it does exist, update it, only if allowOverwrite is set
131            if (!allowOverwrite) {
132                throw new RuntimeException("Attempting to overwrite template " + name + " without allowOverwrite set");
133            }
134
135            // the name should be equal if one was actually found
136            assert(name.equals(ruleTemplate.getName())) : "Existing template definition name does not match incoming definition name";
137        } 
138
139        // overwrite simple properties
140        ruleTemplate.setName(name);
141        ruleTemplate.setDescription(description);
142
143        // update the delegation template
144        updateDelegationTemplate(element, ruleTemplate, ruleTemplates);
145
146        // update the attribute relationships
147        updateRuleTemplateAttributes(element, ruleTemplate);
148
149        // save the rule template first so that the default/template rule that is generated
150        // in the process of setting defaults is associated properly with this rule template
151        ruleTemplate = KEWServiceLocator.getRuleTemplateService().save(ruleTemplate);
152
153        // update the default options
154        updateRuleTemplateDefaultOptions(element, ruleTemplate);
155
156        ruleTemplate = KEWServiceLocator.getRuleTemplateService().save(ruleTemplate);
157
158        return ruleTemplate;
159    }
160
161    /**
162     * Updates the rule template default options.  Updates any existing options, removes any omitted ones.
163     * @param ruleTemplateElement the rule template XML element
164     * @param updatedRuleTemplate the RuleTemplate being updated
165     * @throws XmlException
166     */
167    /*
168     <element name="description" type="c:LongStringType"/>
169     <element name="fromDate" type="c:ShortStringType" minOccurs="0"/>
170     <element name="toDate" type="c:ShortStringType" minOccurs="0"/>
171     <element name="forceAction" type="boolean"/>
172     <element name="active" type="boolean"/>
173     <element name="defaultActionRequested" type="c:ShortStringType"/>
174     <element name="supportsComplete" type="boolean" default="true"/>
175     <element name="supportsApprove" type="boolean" default="true"/>
176     <element name="supportsAcknowledge" type="boolean" default="true"/>
177     <element name="supportsFYI" type="boolean" default="true"/>
178    */
179    protected void updateRuleTemplateDefaultOptions(Element ruleTemplateElement, RuleTemplateBo updatedRuleTemplate) throws XmlException {
180        Element defaultsElement = ruleTemplateElement.getChild(RULE_DEFAULTS, RULE_TEMPLATE_NAMESPACE);
181
182        // update the rule defaults; this yields whether or not this is a delegation rule template
183        boolean isDelegation = updateRuleDefaults(defaultsElement, updatedRuleTemplate);
184
185        // update the rule template options
186        updateRuleTemplateOptions(defaultsElement, updatedRuleTemplate, isDelegation);
187
188    }
189
190    /**
191     * Updates the rule template defaults options with those in the defaults element
192     * @param defaultsElement the ruleDefaults element
193     * @param updatedRuleTemplate the Rule Template being updated
194     */
195    protected void updateRuleTemplateOptions(Element defaultsElement, RuleTemplateBo updatedRuleTemplate, boolean isDelegation) throws XmlException {
196        // the possible defaults options
197        // NOTE: the current implementation will remove any existing RuleTemplateOption records for any values which are null, i.e. not set in the incoming XML.
198        // to pro-actively set default values for omitted options, simply set those values here, and records will be added if not present
199        String defaultActionRequested = null;
200        Boolean supportsComplete = null;
201        Boolean supportsApprove = null;
202        Boolean supportsAcknowledge = null;
203        Boolean supportsFYI = null;
204        
205        // remove any RuleTemplateOptions the template may have but that we know we aren't going to update/reset
206        // (not sure if this case even exists...does anything else set rule template options?)
207        updatedRuleTemplate.removeNonDefaultOptions();
208        
209        // read in new settings
210        if (defaultsElement != null) {
211
212                defaultActionRequested = defaultsElement.getChildText(DEFAULT_ACTION_REQUESTED, RULE_TEMPLATE_NAMESPACE);
213            supportsComplete = BooleanUtils.toBooleanObject(defaultsElement.getChildText(SUPPORTS_COMPLETE, RULE_TEMPLATE_NAMESPACE));
214            supportsApprove = BooleanUtils.toBooleanObject(defaultsElement.getChildText(SUPPORTS_APPROVE, RULE_TEMPLATE_NAMESPACE));
215            supportsAcknowledge = BooleanUtils.toBooleanObject(defaultsElement.getChildText(SUPPORTS_ACKNOWLEDGE, RULE_TEMPLATE_NAMESPACE));
216            supportsFYI = BooleanUtils.toBooleanObject(defaultsElement.getChildText(SUPPORTS_FYI, RULE_TEMPLATE_NAMESPACE));
217        }
218
219        if (!isDelegation) {
220            // if this is not a delegation template, store the template options that govern rule action constraints
221            // in the RuleTemplateOptions of the template
222            // we have two options for this behavior:
223            // 1) conditionally parse above, and then unconditionally set/unset the properties; this will have the effect of REMOVING
224            //    any of these previously specified rule template options (and is arguably the right thing to do)
225            // 2) unconditionally parse above, and then conditionally set/unset the properties; this will have the effect of PRESERVING
226            //    the existing rule template options on this template if it is a delegation template (which of course will be overwritten
227            //    by this very same code if they subsequently upload without the delegation flag)
228            // This is a minor point, but the second implementation is chosen as it preserved the current behavior
229            updateOrDeleteRuleTemplateOption(updatedRuleTemplate, KewApiConstants.ACTION_REQUEST_DEFAULT_CD, defaultActionRequested);
230            updateOrDeleteRuleTemplateOption(updatedRuleTemplate, KewApiConstants.ACTION_REQUEST_APPROVE_REQ, supportsApprove);
231            updateOrDeleteRuleTemplateOption(updatedRuleTemplate, KewApiConstants.ACTION_REQUEST_ACKNOWLEDGE_REQ, supportsAcknowledge);
232            updateOrDeleteRuleTemplateOption(updatedRuleTemplate, KewApiConstants.ACTION_REQUEST_FYI_REQ, supportsFYI);
233            updateOrDeleteRuleTemplateOption(updatedRuleTemplate, KewApiConstants.ACTION_REQUEST_COMPLETE_REQ, supportsComplete);
234        }
235
236    }
237    
238    /**
239     * 
240     * Updates the default/template rule options with those in the defaults element
241     * @param defaultsElement the ruleDefaults element
242     * @param updatedRuleTemplate the Rule Template being updated
243     * @return whether this is a delegation rule template
244     */
245    protected boolean updateRuleDefaults(Element defaultsElement, RuleTemplateBo updatedRuleTemplate) throws XmlException {
246        // NOTE: implementation detail: in contrast with the other options, the delegate template, and the rule attributes,
247        // we unconditionally blow away the default rule and re-create it (we don't update the existing one, if there is one)
248        if (updatedRuleTemplate.getId() != null) {
249            RuleBaseValues ruleDefaults = KEWServiceLocator.getRuleService().findDefaultRuleByRuleTemplateId(updatedRuleTemplate.getId());
250            if (ruleDefaults != null) {
251                List ruleDelegationDefaults = KEWServiceLocator.getRuleDelegationService().findByDelegateRuleId(ruleDefaults.getId());
252                // delete the rule
253                KEWServiceLocator.getRuleService().delete(ruleDefaults.getId());
254                // delete the associated rule delegation defaults
255                for (Iterator iterator = ruleDelegationDefaults.iterator(); iterator.hasNext();) {
256                    RuleDelegationBo ruleDelegation = (RuleDelegationBo) iterator.next();
257                    KEWServiceLocator.getRuleDelegationService().delete(ruleDelegation.getRuleDelegationId());
258                }
259            }
260        }
261
262        boolean isDelegation = false;
263
264        if (defaultsElement != null) {
265            String delegationTypeCode = defaultsElement.getChildText(DELEGATION_TYPE, RULE_TEMPLATE_NAMESPACE);
266            DelegationType delegationType = null;
267            isDelegation = !org.apache.commons.lang.StringUtils.isEmpty(delegationTypeCode);
268
269            String description = defaultsElement.getChildText(DESCRIPTION, RULE_TEMPLATE_NAMESPACE);
270            
271            // would normally be validated via schema but might not be present if invoking RuleXmlParser directly
272            if (description == null) {
273                throw new XmlException("Description must be specified in rule defaults");
274            }
275            
276            String fromDate = defaultsElement.getChildText(FROM_DATE, RULE_TEMPLATE_NAMESPACE);
277            String toDate = defaultsElement.getChildText(TO_DATE, RULE_TEMPLATE_NAMESPACE);
278            // toBooleanObject ensures that if the value is null (not set) that the Boolean object will likewise be null (will not default to a value)
279            Boolean forceAction = BooleanUtils.toBooleanObject(defaultsElement.getChildText(FORCE_ACTION, RULE_TEMPLATE_NAMESPACE));
280            Boolean active = BooleanUtils.toBooleanObject(defaultsElement.getChildText(ACTIVE, RULE_TEMPLATE_NAMESPACE));
281
282            if (isDelegation) {
283                delegationType = DelegationType.parseCode(delegationTypeCode);
284                if (delegationType == null) {
285                    throw new XmlException("Invalid delegation type '" + delegationType + "'." + "  Expected one of: "
286                                            + DelegationType.PRIMARY.getCode() + "," + DelegationType.SECONDARY.getCode());
287                }
288            }
289    
290            // create our "default rule" which encapsulates the defaults for the rule
291            RuleBaseValues ruleDefaults = new RuleBaseValues();
292    
293            // set simple values
294            ruleDefaults.setRuleTemplate(updatedRuleTemplate);
295            ruleDefaults.setRuleTemplateId(updatedRuleTemplate.getId());
296            ruleDefaults.setDocTypeName(DUMMY_DOCUMENT_TYPE);
297            ruleDefaults.setTemplateRuleInd(Boolean.TRUE);
298            ruleDefaults.setCurrentInd(Boolean.TRUE);
299            ruleDefaults.setVersionNbr(new Integer(0));
300            ruleDefaults.setDescription(description);
301    
302            // these are non-nullable fields, so default them if they were not set in the defaults section
303            ruleDefaults.setForceAction(Boolean.valueOf(BooleanUtils.isTrue(forceAction)));
304            ruleDefaults.setActive(Boolean.valueOf(BooleanUtils.isTrue(active)));
305        
306            if (ruleDefaults.getActivationDate() == null) {
307                ruleDefaults.setActivationDate(new Timestamp(System.currentTimeMillis()));
308            }
309    
310            ruleDefaults.setFromDateValue(formatDate("fromDate", fromDate));
311            ruleDefaults.setToDateValue(formatDate("toDate", toDate));
312            
313            // ok, if this is a "Delegate Template", then we need to set this other RuleDelegation object which contains
314            // some delegation-related info
315            RuleDelegationBo ruleDelegationDefaults = null;
316            if (isDelegation) {
317                ruleDelegationDefaults = new RuleDelegationBo();
318                ruleDelegationDefaults.setDelegationRule(ruleDefaults);
319                ruleDelegationDefaults.setDelegationType(delegationType);
320                ruleDelegationDefaults.setResponsibilityId(KewApiConstants.ADHOC_REQUEST_RESPONSIBILITY_ID);
321            }
322
323            // explicitly save the new rule delegation defaults and default rule
324            KEWServiceLocator.getRuleTemplateService().saveRuleDefaults(ruleDelegationDefaults, ruleDefaults);
325        } else {
326            // do nothing, rule defaults will be deleted if ruleDefaults element is omitted
327        }
328        
329        return isDelegation;
330    }
331
332
333    /**
334     * Updates or deletes a specified rule template option on the rule template
335     * @param updatedRuleTemplate the RuleTemplate being updated
336     * @param key the option key
337     * @param value the option value
338     */
339    protected void updateOrDeleteRuleTemplateOption(RuleTemplateBo updatedRuleTemplate, String key, Object value) {
340        if (value != null) {
341            // if the option exists and the incoming value is non-null (it's set), update it
342            RuleTemplateOptionBo option = updatedRuleTemplate.getRuleTemplateOption(key);
343            if (option != null) {
344                option.setValue(value.toString());
345            } else {
346                updatedRuleTemplate.getRuleTemplateOptions().add(new RuleTemplateOptionBo(key, value.toString()));
347            }
348        } else {
349            // otherwise if the incoming value IS null (not set), then explicitly remove the entry (if it exists)
350            Iterator<RuleTemplateOptionBo> options = updatedRuleTemplate.getRuleTemplateOptions().iterator();
351            while (options.hasNext()) {
352                RuleTemplateOptionBo opt = options.next();
353                if (key.equals(opt.getCode())) {
354                    options.remove();
355                    break;
356                }
357            }
358        }
359    }
360
361    /**
362     * Updates the rule template delegation template with the one specified in the XML (if any)
363     * @param ruleTemplateElement the XML ruleTemplate element
364     * @param updatedRuleTemplate the rule template to update
365     * @param parsedRuleTemplates the rule templates parsed in this parsing run
366     * @throws XmlException if a delegation template was specified but could not be found
367     */
368    protected void updateDelegationTemplate(Element ruleTemplateElement, RuleTemplateBo updatedRuleTemplate, List<RuleTemplateBo> parsedRuleTemplates) throws XmlException {
369        String delegateTemplateName = ruleTemplateElement.getChildText(DELEGATION_TEMPLATE, RULE_TEMPLATE_NAMESPACE);
370
371        if (delegateTemplateName != null) {
372            // if a delegateTemplate was set in the XML, then look it up and set it on the RuleTemplate object
373            // first try looking up an existing delegateTemplate in the system
374            RuleTemplateBo delegateTemplate = KEWServiceLocator.getRuleTemplateService().findByRuleTemplateName(delegateTemplateName);
375
376            // if not found, try the list of templates currently parsed
377            if (delegateTemplate == null) {
378                for (RuleTemplateBo rt: parsedRuleTemplates) {
379                    if (delegateTemplateName.equalsIgnoreCase(rt.getName())) {
380                        // set the expected next rule template id on the target delegateTemplate
381                        String ruleTemplateId = KEWServiceLocator.getRuleTemplateService().getNextRuleTemplateId();
382                        rt.setId(ruleTemplateId);
383                        delegateTemplate = rt;
384                        break;
385                    }
386                }
387            }
388
389            if (delegateTemplate == null) {
390                throw new XmlException("Cannot find delegation template " + delegateTemplateName);
391            }
392
393            updatedRuleTemplate.setDelegationTemplateId(delegateTemplate.getDelegationTemplateId());
394            updatedRuleTemplate.setDelegationTemplate(delegateTemplate);           
395        } else {
396            // the previously referenced template is left in the system
397        }
398    }
399
400    /**
401     * Updates the attributes set on the RuleTemplate
402     * @param ruleTemplateElement the XML ruleTemplate element
403     * @param updatedRuleTemplate the RuleTemplate being updated
404     * @throws XmlException if there was a problem parsing the rule template attributes
405     */
406    protected void updateRuleTemplateAttributes(Element ruleTemplateElement, RuleTemplateBo updatedRuleTemplate) throws XmlException {
407        // add any newly defined rule template attributes to the rule template,
408        // update the active and required flags of any existing ones.
409        // if this is an update of an existing rule template, related attribute objects will be present in this rule template object,
410        // otherwise none will be present (so they'll all be new)
411
412        Element attributesElement = ruleTemplateElement.getChild(ATTRIBUTES, RULE_TEMPLATE_NAMESPACE);
413        List<RuleTemplateAttributeBo> incomingAttributes = new ArrayList<RuleTemplateAttributeBo>();
414        if (attributesElement != null) {
415            incomingAttributes.addAll(parseRuleTemplateAttributes(attributesElement, updatedRuleTemplate));
416        }
417
418        // inactivate all current attributes
419        for (RuleTemplateAttributeBo currentRuleTemplateAttribute: updatedRuleTemplate.getRuleTemplateAttributes()) {
420            String ruleAttributeName = (currentRuleTemplateAttribute.getRuleAttribute() != null) ? currentRuleTemplateAttribute.getRuleAttribute().getName() : "(null)";
421            LOG.debug("Inactivating rule template attribute with id " + currentRuleTemplateAttribute.getId() + " and rule attribute with name " + ruleAttributeName);
422            currentRuleTemplateAttribute.setActive(Boolean.FALSE);
423        }
424        // NOTE: attributes are deactivated, not removed
425
426        // add/update any new attributes
427        for (RuleTemplateAttributeBo ruleTemplateAttribute: incomingAttributes) {
428            RuleTemplateAttributeBo potentialExistingTemplateAttribute = updatedRuleTemplate.getRuleTemplateAttribute(ruleTemplateAttribute);
429            if (potentialExistingTemplateAttribute != null) {
430                // template attribute exists on rule template already; update the options
431                potentialExistingTemplateAttribute.setActive(ruleTemplateAttribute.getActive());
432                potentialExistingTemplateAttribute.setRequired(ruleTemplateAttribute.getRequired());
433            } else {
434                // template attribute does not yet exist on template so add it
435                ruleTemplateAttribute.setRuleTemplate(updatedRuleTemplate);
436                updatedRuleTemplate.getRuleTemplateAttributes().add(ruleTemplateAttribute);
437
438            }
439        }
440    }
441
442    /**
443     * Parses the RuleTemplateAttributes defined on the rule template element
444     * @param attributesElement the jdom Element object for the Rule Template attributes
445     * @param ruleTemplate the RuleTemplate object
446     * @return the RuleTemplateAttributes defined on the rule template element
447     * @throws XmlException
448     */
449    private List<RuleTemplateAttributeBo> parseRuleTemplateAttributes(Element attributesElement, RuleTemplateBo ruleTemplate) throws XmlException {
450        List<RuleTemplateAttributeBo> ruleTemplateAttributes = new ArrayList<RuleTemplateAttributeBo>();
451        Collection<Element> attributeElements = XmlHelper.findElements(attributesElement, ATTRIBUTE);
452        for (Iterator iterator = attributeElements.iterator(); iterator.hasNext();) {
453            ruleTemplateAttributes.add(parseRuleTemplateAttribute((Element) iterator.next(), ruleTemplate));
454        }
455        return ruleTemplateAttributes;
456    }
457
458    /**
459     * Parses a rule template attribute
460     * @param element the attribute XML element
461     * @param ruleTemplate the ruleTemplate to update
462     * @return a parsed rule template attribute
463     * @throws XmlException if the attribute does not exist
464     */
465    private RuleTemplateAttributeBo parseRuleTemplateAttribute(Element element, RuleTemplateBo ruleTemplate) throws XmlException {
466        String attributeName = element.getChildText(NAME, RULE_TEMPLATE_NAMESPACE);
467        String requiredValue = element.getChildText(REQUIRED, RULE_TEMPLATE_NAMESPACE);
468        String activeValue = element.getChildText(ACTIVE, RULE_TEMPLATE_NAMESPACE);
469        if (org.apache.commons.lang.StringUtils.isEmpty(attributeName)) {
470            throw new XmlException("Attribute name must be non-empty");
471        }
472        boolean required = DEFAULT_ATTRIBUTE_REQUIRED;
473        if (requiredValue != null) {
474            required = Boolean.parseBoolean(requiredValue);
475        }
476        boolean active = DEFAULT_ATTRIBUTE_ACTIVE;
477        if (activeValue != null) {
478            active = Boolean.parseBoolean(activeValue);
479        }
480        RuleAttribute ruleAttribute = KEWServiceLocator.getRuleAttributeService().findByName(attributeName);
481        if (ruleAttribute == null) {
482            throw new XmlException("Could not locate rule attribute for name '" + attributeName + "'");
483        }
484        RuleTemplateAttributeBo templateAttribute = new RuleTemplateAttributeBo();
485        templateAttribute.setRuleAttribute(ruleAttribute);
486        templateAttribute.setRuleAttributeId(ruleAttribute.getId());
487        templateAttribute.setRuleTemplate(ruleTemplate);
488        templateAttribute.setRequired(Boolean.valueOf(required));
489        templateAttribute.setActive(Boolean.valueOf(active));
490        templateAttribute.setDisplayOrder(new Integer(templateAttributeCounter++));
491        return templateAttribute;
492    }
493    
494    public Timestamp formatDate(String dateLabel, String dateString) throws XmlException {
495        if (StringUtils.isBlank(dateString)) {
496                return null;
497        }
498        try {
499                return new Timestamp(RiceConstants.getDefaultDateFormat().parse(dateString).getTime());
500        } catch (ParseException e) {
501                throw new XmlException(dateLabel + " is not in the proper format.  Should have been: " + RiceConstants.DEFAULT_DATE_FORMAT_PATTERN);
502        }
503    }
504
505}