/**
* Updates or deletes a specified rule template option on the rule template
*
* @param updatedRuleTemplate the RuleTemplate being updated
* @param key the option key
* @param value the option value
*/
protected void updateOrDeleteRuleTemplateOption(
RuleTemplateBo updatedRuleTemplate, String key, Object 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(key, value.toString()));
}
} else {
// otherwise if the incoming value IS null (not set), then explicitly remove the entry (if it
// exists)
Iterator<RuleTemplateOptionBo> options =
updatedRuleTemplate.getRuleTemplateOptions().iterator();
while (options.hasNext()) {
RuleTemplateOptionBo opt = options.next();
if (key.equals(opt.getCode())) {
options.remove();
break;
}
}
}
}
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);
}
protected boolean validateCreateDelegateRule(DelegateRuleForm form) {
if (form.getParentRule() == null) {
GlobalVariables.getMessageMap().putError(PARENT_RULE_PROPERTY, PARENT_RULE_ERROR);
} else {
RuleTemplateBo ruleTemplate = form.getParentRule().getRuleTemplate();
if (ruleTemplate == null || ruleTemplate.getDelegationTemplate() == null) {
GlobalVariables.getMessageMap().putError(PARENT_RULE_PROPERTY, DELEGATE_RULE_INVALID_ERROR);
}
}
if (form.getParentResponsibility() == null) {
GlobalVariables.getMessageMap()
.putError(PARENT_RESPONSIBILITY_PROPERTY, PARENT_RESPONSIBILITY_ERROR);
}
return GlobalVariables.getMessageMap().hasNoErrors();
}
/**
* Updates the attributes set on the RuleTemplate
*
* @param ruleTemplateElement the XML ruleTemplate element
* @param updatedRuleTemplate the RuleTemplate being updated
* @throws XmlException if there was a problem parsing the rule template attributes
*/
protected void updateRuleTemplateAttributes(
Element ruleTemplateElement, RuleTemplateBo updatedRuleTemplate) throws 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(ATTRIBUTES, RULE_TEMPLATE_NAMESPACE);
List<RuleTemplateAttributeBo> incomingAttributes = new ArrayList<RuleTemplateAttributeBo>();
if (attributesElement != null) {
incomingAttributes.addAll(
parseRuleTemplateAttributes(attributesElement, updatedRuleTemplate));
}
// inactivate all current attributes
for (RuleTemplateAttributeBo currentRuleTemplateAttribute :
updatedRuleTemplate.getRuleTemplateAttributes()) {
String ruleAttributeName =
(currentRuleTemplateAttribute.getRuleAttribute() != null)
? currentRuleTemplateAttribute.getRuleAttribute().getName()
: "(null)";
LOG.debug(
"Inactivating rule template attribute with id "
+ currentRuleTemplateAttribute.getId()
+ " and rule attribute with name "
+ ruleAttributeName);
currentRuleTemplateAttribute.setActive(Boolean.FALSE);
}
// NOTE: attributes are deactivated, not removed
// add/update any new attributes
for (RuleTemplateAttributeBo ruleTemplateAttribute : incomingAttributes) {
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
ruleTemplateAttribute.setRuleTemplate(updatedRuleTemplate);
updatedRuleTemplate.getRuleTemplateAttributes().add(ruleTemplateAttribute);
}
}
}
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);
}
}
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);
}
}
}
}
/**
* 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
}
}
/**
* 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;
}
/**
* Updates the rule template defaults options with those in the defaults element
*
* @param defaultsElement the ruleDefaults element
* @param updatedRuleTemplate the Rule Template being updated
*/
protected void updateRuleTemplateOptions(
Element defaultsElement, RuleTemplateBo updatedRuleTemplate, boolean isDelegation)
throws 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(DEFAULT_ACTION_REQUESTED, RULE_TEMPLATE_NAMESPACE);
supportsComplete =
BooleanUtils.toBooleanObject(
defaultsElement.getChildText(SUPPORTS_COMPLETE, RULE_TEMPLATE_NAMESPACE));
supportsApprove =
BooleanUtils.toBooleanObject(
defaultsElement.getChildText(SUPPORTS_APPROVE, RULE_TEMPLATE_NAMESPACE));
supportsAcknowledge =
BooleanUtils.toBooleanObject(
defaultsElement.getChildText(SUPPORTS_ACKNOWLEDGE, RULE_TEMPLATE_NAMESPACE));
supportsFYI =
BooleanUtils.toBooleanObject(
defaultsElement.getChildText(SUPPORTS_FYI, RULE_TEMPLATE_NAMESPACE));
}
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, KewApiConstants.ACTION_REQUEST_DEFAULT_CD, defaultActionRequested);
updateOrDeleteRuleTemplateOption(
updatedRuleTemplate, KewApiConstants.ACTION_REQUEST_APPROVE_REQ, supportsApprove);
updateOrDeleteRuleTemplateOption(
updatedRuleTemplate, KewApiConstants.ACTION_REQUEST_ACKNOWLEDGE_REQ, supportsAcknowledge);
updateOrDeleteRuleTemplateOption(
updatedRuleTemplate, KewApiConstants.ACTION_REQUEST_FYI_REQ, supportsFYI);
updateOrDeleteRuleTemplateOption(
updatedRuleTemplate, KewApiConstants.ACTION_REQUEST_COMPLETE_REQ, supportsComplete);
}
}
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());
}
