Ejemplo n.º 1
0
 /**
  * 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;
       }
     }
   }
 }
Ejemplo n.º 2
0
  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;
  }
Ejemplo n.º 3
0
 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);
 }
Ejemplo n.º 4
0
  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();
  }
Ejemplo n.º 5
0
  /**
   * 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);
    }
  }
Ejemplo n.º 7
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);
       }
     }
   }
 }
Ejemplo n.º 8
0
  /**
   * 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
    }
  }
Ejemplo n.º 9
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;
  }
Ejemplo n.º 10
0
  /**
   * 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());
 }