/**
* Note that the assertion here will fail if you have multiple rules with the same description.
*/
protected void assertExport() throws Exception {
// export all existing rules and their dependencies (document types, rule templates, rule
// attributes)
List oldRules = KEWServiceLocator.getRuleService().fetchAllRules(true);
assertAllRulesHaveUniqueNames(oldRules);
List oldRuleDelegations =
KEWServiceLocator.getRuleDelegationService().findAllCurrentRuleDelegations();
assertAllRuleDelegationsHaveUniqueNames(oldRuleDelegations);
KewExportDataSet dataSet = new KewExportDataSet();
dataSet.getRules().addAll(oldRules);
dataSet.getRuleDelegations().addAll(oldRuleDelegations);
dataSet.getDocumentTypes().addAll(KEWServiceLocator.getDocumentTypeService().findAllCurrent());
dataSet.getRuleTemplates().addAll(KEWServiceLocator.getRuleTemplateService().findAll());
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
ClearDatabaseLifecycle clearLifeCycle = new ClearDatabaseLifecycle();
clearLifeCycle.getTablesToClear().add("KREW_RULE_T");
clearLifeCycle.getTablesToClear().add("KREW_RULE_RSP_T");
clearLifeCycle.getTablesToClear().add("KREW_DLGN_RSP_T");
clearLifeCycle.getTablesToClear().add("KREW_RULE_ATTR_T");
clearLifeCycle.getTablesToClear().add("KREW_RULE_TMPL_T");
clearLifeCycle.getTablesToClear().add("KREW_DOC_TYP_T");
clearLifeCycle.start();
new ClearCacheLifecycle().stop();
// import the exported xml
loadXmlStream(new BufferedInputStream(new ByteArrayInputStream(xmlBytes)));
List newRules = KEWServiceLocator.getRuleService().fetchAllRules(true);
assertEquals("Should have same number of old and new Rules.", oldRules.size(), newRules.size());
for (Iterator iterator = oldRules.iterator(); iterator.hasNext(); ) {
RuleBaseValues oldRule = (RuleBaseValues) iterator.next();
boolean foundRule = false;
for (Iterator iterator2 = newRules.iterator(); iterator2.hasNext(); ) {
RuleBaseValues newRule = (RuleBaseValues) iterator2.next();
if (oldRule.getDescription().equals(newRule.getDescription())) {
assertRuleExport(oldRule, newRule);
foundRule = true;
}
}
assertTrue(
"Could not locate the new rule for description " + oldRule.getDescription(), foundRule);
}
List newRuleDelegations =
KEWServiceLocator.getRuleDelegationService().findAllCurrentRuleDelegations();
assertDelegations(oldRuleDelegations, newRuleDelegations);
}
private void assertAllRulesHaveUniqueNames(List rules) throws Exception {
Set<String> ruleDescriptions = new HashSet<String>();
for (Iterator iterator = rules.iterator(); iterator.hasNext(); ) {
RuleBaseValues rule = (RuleBaseValues) iterator.next();
assertFalse(
"Found 2 rules with the same description '"
+ rule.getDescription()
+ "'. "
+ "In order for this test to work, all rules in the configuration files must have unique descriptions.",
ruleDescriptions.contains(rule.getDescription()));
ruleDescriptions.add(rule.getDescription());
}
}
private RuleDelegationBo getDefaultDelegationValues(RuleBaseValues defaultRuleValues) {
List ruleDelegations =
KEWServiceLocator.getRuleDelegationService()
.findByDelegateRuleId(defaultRuleValues.getId());
if (ruleDelegations.size() > 1) {
LOG.warn("The rule defaults has more than one associated delegation defaults.");
}
return (ruleDelegations.isEmpty() ? null : (RuleDelegationBo) ruleDelegations.get(0));
}
private void exportDefaults(Element parent, RuleTemplateBo ruleTemplate) {
RuleBaseValues defaultRuleValues =
KEWServiceLocator.getRuleService().findDefaultRuleByRuleTemplateId(ruleTemplate.getId());
if (defaultRuleValues != null) {
RuleDelegationBo defaultDelegationValues = getDefaultDelegationValues(defaultRuleValues);
Element defaultsElement = renderer.renderElement(parent, RULE_DEFAULTS);
if (defaultDelegationValues != null) {
renderer.renderTextElement(
defaultsElement,
DELEGATION_TYPE,
defaultDelegationValues.getDelegationType().getCode());
}
renderer.renderTextElement(defaultsElement, DESCRIPTION, defaultRuleValues.getDescription());
if (defaultRuleValues.getFromDateValue() != null) {
renderer.renderDateElement(
defaultsElement, FROM_DATE, defaultRuleValues.getFromDateValue());
}
if (defaultRuleValues.getToDateValue() != null) {
renderer.renderDateElement(defaultsElement, TO_DATE, defaultRuleValues.getToDateValue());
}
renderer.renderBooleanElement(
defaultsElement, FORCE_ACTION, defaultRuleValues.isForceAction(), false);
renderer.renderBooleanElement(defaultsElement, ACTIVE, defaultRuleValues.isActive(), true);
if (defaultDelegationValues == null) {
RuleTemplateOptionBo defaultActionOption = ruleTemplate.getDefaultActionRequestValue();
RuleTemplateOptionBo supportsComplete = ruleTemplate.getComplete();
RuleTemplateOptionBo supportsApprove = ruleTemplate.getApprove();
RuleTemplateOptionBo supportsAck = ruleTemplate.getAcknowledge();
RuleTemplateOptionBo supportsFYI = ruleTemplate.getFyi();
if (defaultActionOption != null) {
String defaultActionValue =
(defaultActionOption == null ? null : defaultActionOption.getValue());
renderer.renderTextElement(defaultsElement, DEFAULT_ACTION_REQUESTED, defaultActionValue);
}
if (supportsComplete != null) {
String supportsCompleteValue = supportsComplete.getValue();
renderer.renderTextElement(defaultsElement, SUPPORTS_COMPLETE, supportsCompleteValue);
}
if (supportsApprove != null) {
String supportsApproveValue = supportsApprove.getValue();
renderer.renderTextElement(defaultsElement, SUPPORTS_APPROVE, supportsApproveValue);
}
if (supportsAck != null) {
String supportsAckValue = supportsAck.getValue();
renderer.renderTextElement(defaultsElement, SUPPORTS_ACKNOWLEDGE, supportsAckValue);
}
if (supportsFYI != null) {
String supportsFYIValue = supportsFYI.getValue();
renderer.renderTextElement(defaultsElement, SUPPORTS_FYI, supportsFYIValue);
}
}
}
}
private void assertRuleExport(RuleBaseValues oldRule, RuleBaseValues newRule) {
assertFalse("Ids should be different.", oldRule.getId().equals(newRule.getId()));
assertEquals(oldRule.isActive(), newRule.isActive());
assertEquals(
DateUtils.round(oldRule.getActivationDate(), Calendar.DATE),
DateUtils.round(newRule.getActivationDate(), Calendar.DATE));
assertEquals(oldRule.getName(), newRule.getName());
assertEquals(oldRule.getCurrentInd(), newRule.getCurrentInd());
assertEquals(oldRule.getDeactivationDate(), newRule.getDeactivationDate());
assertEquals(oldRule.getDelegateRule(), newRule.getDelegateRule());
assertEquals(oldRule.getDescription(), newRule.getDescription());
assertEquals(oldRule.getDocTypeName(), newRule.getDocTypeName());
if (oldRule.getFromDateValue() == null) {
assertNull(newRule.getFromDateValue());
} else {
assertEquals(
DateUtils.round(oldRule.getFromDateValue(), Calendar.DATE),
DateUtils.round(newRule.getFromDateValue(), Calendar.DATE));
}
if (oldRule.getToDateValue() == null) {
assertNull(newRule.getToDateValue());
} else {
assertEquals(
DateUtils.round(oldRule.getToDateValue(), Calendar.DATE),
DateUtils.round(newRule.getToDateValue(), Calendar.DATE));
}
assertEquals(oldRule.getFromDateString(), newRule.getFromDateString());
assertEquals(oldRule.getToDateString(), newRule.getToDateString());
assertEquals(oldRule.isForceAction(), newRule.isForceAction());
if (!oldRule.getDelegateRule().booleanValue())
assertEquals(oldRule.getPreviousVersionId(), newRule.getPreviousVersionId());
assertEquals(oldRule.getDocumentId(), newRule.getDocumentId());
if (oldRule.getRuleTemplate() == null) {
assertNull(newRule.getRuleTemplate());
} else {
assertEquals(oldRule.getRuleTemplate().getName(), newRule.getRuleTemplate().getName());
}
if (oldRule.getRuleExpressionDef() == null) {
assertNull(newRule.getRuleExpressionDef());
} else {
assertEquals(
oldRule.getRuleExpressionDef().getExpression(),
newRule.getRuleExpressionDef().getExpression());
assertEquals(
oldRule.getRuleExpressionDef().getType(), newRule.getRuleExpressionDef().getType());
}
if (!oldRule.getDelegateRule().booleanValue())
assertEquals(oldRule.getVersionNbr(), newRule.getVersionNbr());
assertRuleExtensions(oldRule.getRuleExtensions(), newRule.getRuleExtensions());
assertResponsibilities(oldRule.getRuleResponsibilities(), newRule.getRuleResponsibilities());
}
/**
* Updates the default/template rule options with those in the defaults element
*
* @param defaultsElement the ruleDefaults element
* @param updatedRuleTemplate the Rule Template being updated
* @return whether this is a delegation rule template
*/
protected boolean updateRuleDefaults(Element defaultsElement, RuleTemplateBo updatedRuleTemplate)
throws 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 = (RuleDelegationBo) iterator.next();
KEWServiceLocator.getRuleDelegationService().delete(ruleDelegation.getRuleDelegationId());
}
}
}
boolean isDelegation = false;
if (defaultsElement != null) {
String delegationTypeCode =
defaultsElement.getChildText(DELEGATION_TYPE, RULE_TEMPLATE_NAMESPACE);
DelegationType delegationType = null;
isDelegation = !org.apache.commons.lang.StringUtils.isEmpty(delegationTypeCode);
String description = defaultsElement.getChildText(DESCRIPTION, RULE_TEMPLATE_NAMESPACE);
// 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(FROM_DATE, RULE_TEMPLATE_NAMESPACE);
String toDate = defaultsElement.getChildText(TO_DATE, RULE_TEMPLATE_NAMESPACE);
// 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(FORCE_ACTION, RULE_TEMPLATE_NAMESPACE));
Boolean active =
BooleanUtils.toBooleanObject(
defaultsElement.getChildText(ACTIVE, RULE_TEMPLATE_NAMESPACE));
if (isDelegation) {
delegationType = DelegationType.parseCode(delegationTypeCode);
if (delegationType == null) {
throw new XmlException(
"Invalid delegation type '"
+ delegationType
+ "'."
+ " Expected one of: "
+ DelegationType.PRIMARY.getCode()
+ ","
+ DelegationType.SECONDARY.getCode());
}
}
// create our "default rule" which encapsulates the defaults for the rule
RuleBaseValues ruleDefaults = new RuleBaseValues();
// set simple values
ruleDefaults.setRuleTemplate(updatedRuleTemplate);
ruleDefaults.setRuleTemplateId(updatedRuleTemplate.getId());
ruleDefaults.setDocTypeName(DUMMY_DOCUMENT_TYPE);
ruleDefaults.setTemplateRuleInd(Boolean.TRUE);
ruleDefaults.setCurrentInd(Boolean.TRUE);
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(KewApiConstants.ADHOC_REQUEST_RESPONSIBILITY_ID);
}
// explicitly save the new rule delegation defaults and default rule
KEWServiceLocator.getRuleTemplateService()
.saveRuleDefaults(ruleDelegationDefaults, ruleDefaults);
} else {
// do nothing, rule defaults will be deleted if ruleDefaults element is omitted
}
return isDelegation;
}
