private RuleSetRuleBean createRuleSetRule(RuleSetBean ruleSet, String ruleOid, String oidRef) {
    RuleSetRuleBean ruleSetRule = new RuleSetRuleBean();
    // DiscrepancyNoteActionBean ruleAction = new DiscrepancyNoteActionBean();
    EventActionBean ruleAction = new EventActionBean();
    ruleAction.setOc_oid_reference(oidRef);
    ruleAction.setExpressionEvaluatesTo(true);
    ruleSetRule.addAction(ruleAction);
    ruleSetRule.setRuleSetBean(ruleSet);
    ruleSetRule.setOid(ruleOid);

    return ruleSetRule;
  }
Ejemplo n.º 2
0
  private RulesPostImportContainer mapRulesToRulesPostImportContainer(
      org.openclinica.ns.rules.v31.Rules rules) {
    RulesPostImportContainer rpic = new RulesPostImportContainer();

    for (RuleAssignmentType rat : rules.getRuleAssignment()) {
      TargetType targetType = rat.getTarget();
      ExpressionBean targetBean = new ExpressionBean(Context.OC_RULES_V1, targetType.getValue());
      RunOnScheduleType scheduleType = rules.getRuleAssignment().get(0).getRunOnSchedule();
      RuleSetBean ruleSetBean = new RuleSetBean();
      ruleSetBean.setOriginalTarget(targetBean);
      if (scheduleType != null) {
        if (!scheduleType.getTime().equals("")) {
          ruleSetBean.setRunTime(scheduleType.getTime());
        }
      }

      for (RuleRefType rrt : rat.getRuleRef()) {
        RuleSetRuleBean ruleSetRuleBean = new RuleSetRuleBean();
        ruleSetRuleBean.setOid(rrt.getOID());

        for (DiscrepancyNoteActionType discrepancyNoteActionType : rrt.getDiscrepancyNoteAction()) {
          DiscrepancyNoteActionBean action = new DiscrepancyNoteActionBean();
          action.setMessage(discrepancyNoteActionType.getMessage());
          action.setExpressionEvaluatesTo(
              Boolean.valueOf(discrepancyNoteActionType.getIfExpressionEvaluates()));
          action
              .getRuleActionRun()
              .setInitialDataEntry(discrepancyNoteActionType.getRun().isInitialDataEntry());
          action
              .getRuleActionRun()
              .setDoubleDataEntry(discrepancyNoteActionType.getRun().isDoubleDataEntry());
          action
              .getRuleActionRun()
              .setAdministrativeDataEntry(
                  discrepancyNoteActionType.getRun().isAdministrativeDataEntry());
          action
              .getRuleActionRun()
              .setImportDataEntry(discrepancyNoteActionType.getRun().isImportDataEntry());
          action.getRuleActionRun().setBatch(discrepancyNoteActionType.getRun().isBatch());
          ruleSetRuleBean.addAction(action);
        }
        for (EmailActionType emailActionType : rrt.getEmailAction()) {
          EmailActionBean action = new EmailActionBean();
          action.setMessage(emailActionType.getMessage());
          action.setTo(emailActionType.getTo());
          action.setExpressionEvaluatesTo(
              Boolean.valueOf(emailActionType.getIfExpressionEvaluates()));
          action
              .getRuleActionRun()
              .setInitialDataEntry(emailActionType.getRun().isInitialDataEntry());
          action
              .getRuleActionRun()
              .setDoubleDataEntry(emailActionType.getRun().isDoubleDataEntry());
          action
              .getRuleActionRun()
              .setAdministrativeDataEntry(emailActionType.getRun().isAdministrativeDataEntry());
          action
              .getRuleActionRun()
              .setImportDataEntry(emailActionType.getRun().isImportDataEntry());
          action.getRuleActionRun().setBatch(emailActionType.getRun().isBatch());
          ruleSetRuleBean.addAction(action);
        }
        for (ShowActionType showActionType : rrt.getShowAction()) {
          ShowActionBean action = new ShowActionBean();
          action.setMessage(showActionType.getMessage());
          action.setExpressionEvaluatesTo(
              Boolean.valueOf(showActionType.getIfExpressionEvaluates()));
          action
              .getRuleActionRun()
              .setInitialDataEntry(showActionType.getRun().isInitialDataEntry());
          action.getRuleActionRun().setDoubleDataEntry(showActionType.getRun().isDoubleDataEntry());
          action
              .getRuleActionRun()
              .setAdministrativeDataEntry(showActionType.getRun().isAdministrativeDataEntry());
          action.getRuleActionRun().setImportDataEntry(showActionType.getRun().isImportDataEntry());
          action.getRuleActionRun().setBatch(showActionType.getRun().isBatch());
          for (PropertyType propertyType : showActionType.getDestinationProperty()) {
            PropertyBean property = new PropertyBean();
            property.setOid(propertyType.getOID());
            action.addProperty(property);
          }
          ruleSetRuleBean.addAction(action);
        }
        for (HideActionType hideActionType : rrt.getHideAction()) {
          HideActionBean action = new HideActionBean();
          action.setMessage(hideActionType.getMessage());
          action.setExpressionEvaluatesTo(
              Boolean.valueOf(hideActionType.getIfExpressionEvaluates()));
          action
              .getRuleActionRun()
              .setInitialDataEntry(hideActionType.getRun().isInitialDataEntry());
          action.getRuleActionRun().setDoubleDataEntry(hideActionType.getRun().isDoubleDataEntry());
          action
              .getRuleActionRun()
              .setAdministrativeDataEntry(hideActionType.getRun().isAdministrativeDataEntry());
          action.getRuleActionRun().setImportDataEntry(hideActionType.getRun().isImportDataEntry());
          action.getRuleActionRun().setBatch(hideActionType.getRun().isBatch());
          for (PropertyType propertyType : hideActionType.getDestinationProperty()) {
            PropertyBean property = new PropertyBean();
            property.setOid(propertyType.getOID());
            action.addProperty(property);
          }
          ruleSetRuleBean.addAction(action);
        }
        for (InsertActionType insertActionType : rrt.getInsertAction()) {
          InsertActionBean action = new InsertActionBean();
          action.setExpressionEvaluatesTo(
              Boolean.valueOf(insertActionType.getIfExpressionEvaluates()));
          action
              .getRuleActionRun()
              .setInitialDataEntry(insertActionType.getRun().isInitialDataEntry());
          action
              .getRuleActionRun()
              .setDoubleDataEntry(insertActionType.getRun().isDoubleDataEntry());
          action
              .getRuleActionRun()
              .setAdministrativeDataEntry(insertActionType.getRun().isAdministrativeDataEntry());
          action
              .getRuleActionRun()
              .setImportDataEntry(insertActionType.getRun().isImportDataEntry());
          action.getRuleActionRun().setBatch(insertActionType.getRun().isBatch());
          ruleSetRuleBean.addAction(action);
          for (PropertyType propertyType : insertActionType.getDestinationProperty()) {
            PropertyBean property = new PropertyBean();
            property.setOid(propertyType.getOID());
            property.setValue(propertyType.getValue());
            ExpressionBean expressionBean =
                new ExpressionBean(
                    Context.OC_RULES_V1, propertyType.getValueExpression().getValue());
            property.setValueExpression(expressionBean);
            action.addProperty(property);
          }
          ruleSetRuleBean.addAction(action);
        }

        for (EventActionType eventActionType : rrt.getEventAction()) {
          EventActionBean action = new EventActionBean();
          action.setExpressionEvaluatesTo(
              Boolean.valueOf(eventActionType.getIfExpressionEvaluates()));
          action.setOc_oid_reference(eventActionType.getOID());
          action
              .getRuleActionRun()
              .setNot_started(eventActionType.getRunOnStatus().isNotScheduled());
          action.getRuleActionRun().setScheduled(eventActionType.getRunOnStatus().isScheduled());
          action
              .getRuleActionRun()
              .setData_entry_started(eventActionType.getRunOnStatus().isDataEntryStarted());
          action.getRuleActionRun().setComplete(eventActionType.getRunOnStatus().isCompleted());
          action.getRuleActionRun().setSkipped(eventActionType.getRunOnStatus().isSkipped());
          action.getRuleActionRun().setStopped(eventActionType.getRunOnStatus().isStopped());
          for (EventDestinationType eventDestinationType : eventActionType.getEventDestination()) {
            EventPropertyBean property = new EventPropertyBean();
            property.setProperty(eventDestinationType.getProperty());
            ExpressionBean expressionBean =
                new ExpressionBean(
                    Context.OC_RULES_V1, eventDestinationType.getValueExpression().getValue());
            property.setValueExpression(expressionBean);
            action.addProperty(property);
          }
          ruleSetRuleBean.addAction(action);
        }

        for (NotificationActionType notificationActionType : rrt.getNotificationAction()) {
          NotificationActionBean action = new NotificationActionBean();
          action.setExpressionEvaluatesTo(
              Boolean.valueOf(notificationActionType.getIfExpressionEvaluates()));
          action.setTo(notificationActionType.getTo());
          action.setSubject(notificationActionType.getSubject());
          action.setMessage(notificationActionType.getMessage());
          ruleSetRuleBean.addAction(action);
        }

        ruleSetBean.addRuleSetRule(ruleSetRuleBean);
      }
      rpic.addRuleSet(ruleSetBean);
    }

    for (RuleDefType rdt : rules.getRuleDef()) {
      RuleBean ruleBean = new RuleBean();
      ExpressionBean ruleExpressionBean =
          new ExpressionBean(Context.OC_RULES_V1, rdt.getExpression().getValue());
      ruleBean.setExpression(ruleExpressionBean);
      ruleBean.setDescription(rdt.getDescription());
      ruleBean.setName(rdt.getName());
      ruleBean.setOid(rdt.getOID());
      rpic.addRuleDef(ruleBean);
    }

    return rpic;
  }