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());
  }
 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));
 }
  /**
   * 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;
  }