private RuleTemplateBo parseRuleTemplate(Element element, List<RuleTemplateBo> ruleTemplates)
throws XmlException {
String name = element.getChildText(NAME, RULE_TEMPLATE_NAMESPACE);
String description = element.getChildText(DESCRIPTION, RULE_TEMPLATE_NAMESPACE);
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(element, ruleTemplate, ruleTemplates);
// update the attribute relationships
updateRuleTemplateAttributes(element, ruleTemplate);
// 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
ruleTemplate = KEWServiceLocator.getRuleTemplateService().save(ruleTemplate);
// update the default options
updateRuleTemplateDefaultOptions(element, ruleTemplate);
ruleTemplate = KEWServiceLocator.getRuleTemplateService().save(ruleTemplate);
return ruleTemplate;
}
private void exportRuleTemplate(Element parent, RuleTemplateBo ruleTemplate) {
Element templateElement = renderer.renderElement(parent, RULE_TEMPLATE);
renderer.renderTextElement(templateElement, NAME, ruleTemplate.getName());
renderer.renderTextElement(templateElement, DESCRIPTION, ruleTemplate.getDescription());
if (ruleTemplate.getDelegationTemplate() != null) {
renderer.renderTextElement(
templateElement, DELEGATION_TEMPLATE, ruleTemplate.getDelegationTemplate().getName());
}
exportAttributes(templateElement, ruleTemplate.getActiveRuleTemplateAttributes());
exportDefaults(templateElement, ruleTemplate);
}
private void assertRuleTemplateExport(
RuleTemplateBo oldRuleTemplate, RuleTemplateBo newRuleTemplate) {
assertFalse(
"Ids should be different.", oldRuleTemplate.getId().equals(newRuleTemplate.getId()));
assertEquals(oldRuleTemplate.getDescription(), newRuleTemplate.getDescription());
assertEquals(oldRuleTemplate.getName(), newRuleTemplate.getName());
if (oldRuleTemplate.getDelegationTemplate() != null) {
assertRuleTemplateExport(
oldRuleTemplate.getDelegationTemplate(), newRuleTemplate.getDelegationTemplate());
} else {
assertNull(newRuleTemplate.getDelegationTemplate());
}
assertAttributes(
oldRuleTemplate.getRuleTemplateAttributes(),
newRuleTemplate.getRuleTemplateAttributes(),
"attribute");
assertAttributes(
oldRuleTemplate.getActiveRuleTemplateAttributes(),
newRuleTemplate.getActiveRuleTemplateAttributes(),
"active attribute");
assertOptions(
oldRuleTemplate.getRuleTemplateOptions(), newRuleTemplate.getRuleTemplateOptions());
}
protected void assertExport() throws Exception {
// export all existing rule templates and their dependencies (rule attributes)
List oldRuleTemplates = KEWServiceLocator.getRuleTemplateService().findAll();
KewExportDataSet dataSet = new KewExportDataSet();
dataSet.getRuleTemplates().addAll(oldRuleTemplates);
dataSet.getRuleAttributes().addAll(KEWServiceLocator.getRuleAttributeService().findAll());
byte[] xmlBytes =
CoreApiServiceLocator.getXmlExporterService().export(dataSet.createExportDataSet());
assertTrue("XML should be non empty.", xmlBytes != null && xmlBytes.length > 0);
// now clear the tables
new ClearDatabaseLifecycle(getPerTestTablesToClear(), getPerTestTablesNotToClear()).start();
// import the exported xml
loadXmlStream(new BufferedInputStream(new ByteArrayInputStream(xmlBytes)));
List newRuleTemplates = KEWServiceLocator.getRuleTemplateService().findAll();
assertEquals(
"Should have same number of old and new RuleTemplates.",
oldRuleTemplates.size(),
newRuleTemplates.size());
for (Iterator iterator = oldRuleTemplates.iterator(); iterator.hasNext(); ) {
RuleTemplateBo oldRuleTemplate = (RuleTemplateBo) iterator.next();
boolean foundTemplate = false;
for (Iterator iterator2 = newRuleTemplates.iterator(); iterator2.hasNext(); ) {
RuleTemplateBo newRuleTemplate = (RuleTemplateBo) iterator2.next();
if (oldRuleTemplate.getName().equals(newRuleTemplate.getName())) {
assertRuleTemplateExport(oldRuleTemplate, newRuleTemplate);
foundTemplate = true;
}
}
assertTrue(
"Could not locate the new rule template for name " + oldRuleTemplate.getName(),
foundTemplate);
}
}
/**
* Updates the rule template delegation template with the one specified in the XML (if any)
*
* @param ruleTemplateElement the XML ruleTemplate element
* @param updatedRuleTemplate the rule template to update
* @param parsedRuleTemplates the rule templates parsed in this parsing run
* @throws XmlException if a delegation template was specified but could not be found
*/
protected void updateDelegationTemplate(
Element ruleTemplateElement,
RuleTemplateBo updatedRuleTemplate,
List<RuleTemplateBo> parsedRuleTemplates)
throws XmlException {
String delegateTemplateName =
ruleTemplateElement.getChildText(DELEGATION_TEMPLATE, RULE_TEMPLATE_NAMESPACE);
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 rt : parsedRuleTemplates) {
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
}
}