private boolean isRuleOidValid(AuditableBeanWrapper<RuleBean> ruleBeanWrapper) {
boolean isValid = true;
try {
oidGenerator.validate(ruleBeanWrapper.getAuditableBean().getOid());
} catch (Exception e) {
ruleBeanWrapper.error("OID is not Valid, The OID can only be made of A-Z_0-9");
isValid = false;
}
return isValid;
}
private boolean isRuleSetExpressionValid(AuditableBeanWrapper<RuleSetBean> beanWrapper) {
boolean isValid = true;
ExpressionBean expressionBean =
isExpressionValid(beanWrapper.getAuditableBean().getTarget(), beanWrapper);
ExpressionObjectWrapper eow = new ExpressionObjectWrapper(ds, currentStudy, expressionBean);
ExpressionProcessor ep = ExpressionProcessorFactory.createExpressionProcessor(eow);
String errorString = ep.isRuleAssignmentExpressionValid();
if (errorString != null) {
beanWrapper.error(errorString);
isValid = false;
}
return isValid;
}
@RequestMapping(value = "/studies/{study}/validateAndSaveRule", method = RequestMethod.POST)
public @ResponseBody Response validateAndSave(
@RequestBody org.openclinica.ns.rules.v31.Rules rules,
Model model,
HttpSession session,
@PathVariable("study") String studyOid,
@RequestParam("ignoreDuplicates") Boolean ignoreDuplicates)
throws Exception {
ResourceBundleProvider.updateLocale(new Locale("en_US"));
RulesPostImportContainer rpic = mapRulesToRulesPostImportContainer(rules);
StudyDAO studyDao = new StudyDAO(dataSource);
StudyBean currentStudy = studyDao.findByOid(studyOid);
UserAccountBean userAccount = getUserAccount();
mayProceed(userAccount, currentStudy);
getRulePostImportContainerService(currentStudy, userAccount);
rpic = getRulePostImportContainerService(currentStudy, userAccount).validateRuleDefs(rpic);
rpic = getRulePostImportContainerService(currentStudy, userAccount).validateRuleSetDefs(rpic);
Response response = new Response();
response.setValid(Boolean.TRUE);
if (rpic.getInValidRuleDefs().size() > 0 || rpic.getInValidRuleSetDefs().size() > 0) {
response.setValid(Boolean.FALSE);
for (AuditableBeanWrapper<RuleBean> beanWrapper : rpic.getInValidRuleDefs()) {
for (String error : beanWrapper.getImportErrors()) {
org.openclinica.ns.response.v31.MessagesType messageType = new MessagesType();
messageType.setMessage(error);
response.getMessages().add(messageType);
}
}
for (AuditableBeanWrapper<RuleSetBean> beanWrapper : rpic.getInValidRuleSetDefs()) {
for (String error : beanWrapper.getImportErrors()) {
org.openclinica.ns.response.v31.MessagesType messageType = new MessagesType();
messageType.setMessage(error);
response.getMessages().add(messageType);
}
}
} else if ((rpic.getDuplicateRuleDefs().size() > 0) && !ignoreDuplicates) {
response.setValid(Boolean.FALSE);
for (AuditableBeanWrapper<RuleBean> beanWrapper : rpic.getDuplicateRuleDefs()) {
org.openclinica.ns.response.v31.MessagesType messageType = new MessagesType();
messageType.setMessage(DUPLICATE_MESSAGE);
response.getMessages().add(messageType);
}
} else {
getRuleSetService().saveImportFromDesigner(rpic);
}
logger.debug("RPIC READY");
return response;
}
public RulesPostImportContainer validateRuleDefs(RulesPostImportContainer importContainer) {
for (RuleBean ruleBean : importContainer.getRuleDefs()) {
AuditableBeanWrapper<RuleBean> ruleBeanWrapper = new AuditableBeanWrapper<RuleBean>(ruleBean);
if (isRuleOidValid(ruleBeanWrapper) && isRuleExpressionValid(ruleBeanWrapper, null)) {
RuleBean persistentRuleBean = getRuleDao().findByOid(ruleBeanWrapper.getAuditableBean());
if (persistentRuleBean != null) {
String name = ruleBeanWrapper.getAuditableBean().getName();
String expressionValue = ruleBeanWrapper.getAuditableBean().getExpression().getValue();
String expressionContextName =
ruleBeanWrapper.getAuditableBean().getExpression().getContextName();
Context context =
expressionContextName != null
? Context.getByName(expressionContextName)
: Context.OC_RULES_V1;
ruleBeanWrapper.setAuditableBean(persistentRuleBean);
ruleBeanWrapper.getAuditableBean().setName(name);
ruleBeanWrapper.getAuditableBean().getExpression().setValue(expressionValue);
ruleBeanWrapper.getAuditableBean().getExpression().setContext(context);
// ruleBeanWrapper.getAuditableBean().setId(persistentRuleBean.getId());
// ruleBeanWrapper.getAuditableBean().getExpression().setId(persistentRuleBean.getExpression().getId());
}
}
putRuleInCorrectContainer(ruleBeanWrapper, importContainer);
}
logger.info(
"# of Valid RuleDefs : {} , # of InValid RuleDefs : {} , # of Overwritable RuleDefs : {}",
new Object[] {
importContainer.getValidRuleDefs().size(),
importContainer.getInValidRuleDefs().size(),
importContainer.getDuplicateRuleDefs().size()
});
return importContainer;
}
public RulesPostImportContainer validateRuleSetDefs(RulesPostImportContainer importContainer) {
for (RuleSetBean ruleSetBean : importContainer.getRuleSets()) {
AuditableBeanWrapper<RuleSetBean> ruleSetBeanWrapper =
new AuditableBeanWrapper<RuleSetBean>(ruleSetBean);
ruleSetBeanWrapper.getAuditableBean().setStudy(currentStudy);
if (isRuleSetExpressionValid(ruleSetBeanWrapper)) {
RuleSetBean persistentRuleSetBean = getRuleSetDao().findByExpression(ruleSetBean);
if (persistentRuleSetBean != null) {
List<RuleSetRuleBean> importedRuleSetRules =
ruleSetBeanWrapper.getAuditableBean().getRuleSetRules();
ruleSetBeanWrapper.setAuditableBean(persistentRuleSetBean);
ruleSetBeanWrapper.getAuditableBean().addRuleSetRules(importedRuleSetRules);
// ruleSetBeanWrapper.getAuditableBean().setId(persistentRuleSetBean.getId());
} else {
if (importContainer
.getValidRuleSetExpressionValues()
.contains(ruleSetBeanWrapper.getAuditableBean().getTarget().getValue())) {
ruleSetBeanWrapper.error(
"You have two rule assignments with exact same Target, Combine and try again");
}
ruleSetBeanWrapper
.getAuditableBean()
.setStudyEventDefinition(
getExpressionService()
.getStudyEventDefinitionFromExpression(ruleSetBean.getTarget().getValue()));
ruleSetBeanWrapper
.getAuditableBean()
.setCrf(
getExpressionService().getCRFFromExpression(ruleSetBean.getTarget().getValue()));
ruleSetBeanWrapper
.getAuditableBean()
.setCrfVersion(
getExpressionService()
.getCRFVersionFromExpression(ruleSetBean.getTarget().getValue()));
}
isRuleSetRuleValid(importContainer, ruleSetBeanWrapper);
}
putRuleSetInCorrectContainer(ruleSetBeanWrapper, importContainer);
}
logger.info("# of Valid RuleSetDefs : " + importContainer.getValidRuleSetDefs().size());
logger.info("# of InValid RuleSetDefs : " + importContainer.getInValidRuleSetDefs().size());
logger.info(
"# of Overwritable RuleSetDefs : " + importContainer.getDuplicateRuleSetDefs().size());
return importContainer;
}
private void putRuleInCorrectContainer(
AuditableBeanWrapper<RuleBean> ruleBeanWrapper, RulesPostImportContainer importContainer) {
if (!ruleBeanWrapper.isSavable()) {
importContainer.getInValidRuleDefs().add(ruleBeanWrapper);
importContainer
.getInValidRules()
.put(ruleBeanWrapper.getAuditableBean().getOid(), ruleBeanWrapper);
} else if (ruleBeanWrapper.getAuditableBean().getId() == null) {
importContainer.getValidRuleDefs().add(ruleBeanWrapper);
importContainer
.getValidRules()
.put(ruleBeanWrapper.getAuditableBean().getOid(), ruleBeanWrapper);
} else if (ruleBeanWrapper.getAuditableBean().getId() != null) {
importContainer.getDuplicateRuleDefs().add(ruleBeanWrapper);
importContainer
.getValidRules()
.put(ruleBeanWrapper.getAuditableBean().getOid(), ruleBeanWrapper);
}
}
private void putRuleSetInCorrectContainer(
AuditableBeanWrapper<RuleSetBean> ruleSetBeanWrapper,
RulesPostImportContainer importContainer) {
if (!ruleSetBeanWrapper.isSavable()) {
importContainer.getInValidRuleSetDefs().add(ruleSetBeanWrapper);
} else if (getExpressionService()
.getEventDefinitionCRF(ruleSetBeanWrapper.getAuditableBean().getTarget().getValue())
.getStatus()
.isDeleted()) {
importContainer.getInValidRuleSetDefs().add(ruleSetBeanWrapper);
} else if (ruleSetBeanWrapper.getAuditableBean().getId() == null) {
importContainer.getValidRuleSetDefs().add(ruleSetBeanWrapper);
importContainer
.getValidRuleSetExpressionValues()
.add(ruleSetBeanWrapper.getAuditableBean().getTarget().getValue());
} else if (ruleSetBeanWrapper.getAuditableBean().getId() != null) {
importContainer.getDuplicateRuleSetDefs().add(ruleSetBeanWrapper);
}
}
private ExpressionBean isExpressionValid(
ExpressionBean expressionBean, AuditableBeanWrapper<?> beanWrapper) {
if (expressionBean.getContextName() == null && expressionBean.getContext() == null) {
expressionBean.setContext(Context.OC_RULES_V1);
}
if (expressionBean.getContextName() != null && expressionBean.getContext() == null) {
beanWrapper.warning("The Context you selected is not support we will use the default one");
expressionBean.setContext(Context.OC_RULES_V1);
}
return expressionBean;
}
/**
* If the RuleSet contains any RuleSetRule object with an invalid RuleRef OID (OID that is not in
* DB or in the Valid Rule Lists) , Then add an error to the ruleSetBeanWrapper, which in terms
* will make the RuleSet inValid.
*
* @param importContainer
* @param ruleSetBeanWrapper
*/
private void isRuleSetRuleValid(
RulesPostImportContainer importContainer,
AuditableBeanWrapper<RuleSetBean> ruleSetBeanWrapper) {
for (RuleSetRuleBean ruleSetRuleBean :
ruleSetBeanWrapper.getAuditableBean().getRuleSetRules()) {
String ruleDefOid = ruleSetRuleBean.getOid();
if (ruleSetRuleBean.getId() == null) {
if (getExpressionService()
.getEventDefinitionCRF(ruleSetBeanWrapper.getAuditableBean().getTarget().getValue())
.getStatus()
.isDeleted()) {
ruleSetBeanWrapper.error(
"This is an invalid Rule Set because the target is pointing to an item in the event definition CRF that has a status of removed");
}
if (importContainer.getInValidRules().get(ruleDefOid) != null
|| importContainer.getValidRules().get(ruleDefOid) == null
&& getRuleDao().findByOid(ruleDefOid) == null) {
ruleSetBeanWrapper.error(
"The Rule you are trying to reference does not exist or is Invalid");
}
if (importContainer.getValidRules().get(ruleDefOid) != null) {
AuditableBeanWrapper<RuleBean> r = importContainer.getValidRules().get(ruleDefOid);
if (!isRuleExpressionValid(r, ruleSetBeanWrapper.getAuditableBean()))
ruleSetBeanWrapper.error(
"The Contextual expression in one of the Rules does not validate against the Target expression in the Current RuleSet");
}
}
}
}
@RequestMapping(value = "/studies/{study}/validateAndTestRule", method = RequestMethod.POST)
public @ResponseBody org.openclinica.ns.rules_test.v31.RulesTest create(
@RequestBody org.openclinica.ns.rules_test.v31.RulesTest ruleTest,
Model model,
HttpSession session,
@PathVariable("study") String studyOid)
throws Exception {
ResourceBundleProvider.updateLocale(new Locale("en_US"));
RulesPostImportContainer rpic = mapRulesToRulesPostImportContainer(ruleTest.getRules());
StudyDAO studyDao = new StudyDAO(dataSource);
StudyBean currentStudy = studyDao.findByOid(studyOid);
UserAccountBean userAccount = getUserAccount();
mayProceed(userAccount, currentStudy);
getRulePostImportContainerService(currentStudy, userAccount);
rpic = getRulePostImportContainerService(currentStudy, userAccount).validateRuleDefs(rpic);
rpic = getRulePostImportContainerService(currentStudy, userAccount).validateRuleSetDefs(rpic);
Response response = new Response();
response.setValid(Boolean.TRUE);
if (rpic.getInValidRuleDefs().size() > 0 || rpic.getInValidRuleSetDefs().size() > 0) {
response.setValid(Boolean.FALSE);
for (AuditableBeanWrapper<RuleBean> beanWrapper : rpic.getInValidRuleDefs()) {
for (String error : beanWrapper.getImportErrors()) {
org.openclinica.ns.response.v31.MessagesType messageType = new MessagesType();
messageType.setMessage(error);
response.getMessages().add(messageType);
}
}
for (AuditableBeanWrapper<RuleSetBean> beanWrapper : rpic.getInValidRuleSetDefs()) {
for (String error : beanWrapper.getImportErrors()) {
org.openclinica.ns.response.v31.MessagesType messageType = new MessagesType();
messageType.setMessage(error);
response.getMessages().add(messageType);
}
}
}
HashMap<String, String> p = new HashMap<String, String>();
for (ParameterType parameterType : ruleTest.getParameters()) {
p.put(parameterType.getKey(), parameterType.getValue());
}
ExpressionObjectWrapper eow =
new ExpressionObjectWrapper(
dataSource,
currentStudy,
rpic.getRuleDefs().get(0).getExpression(),
rpic.getRuleSets().get(0));
ExpressionProcessor ep = ExpressionProcessorFactory.createExpressionProcessor(eow);
// Run expression with populated HashMap
DateTime start = new DateTime();
HashMap<String, String> result = ep.testEvaluateExpression(p);
DateTime end = new DateTime();
Duration dur = new Duration(start, end);
PeriodFormatter yearsAndMonths =
new PeriodFormatterBuilder()
.printZeroAlways()
.appendSecondsWithMillis()
.appendSuffix(" second", " seconds")
.toFormatter();
yearsAndMonths.print(dur.toPeriod());
// Run expression with empty HashMap to check rule validity, because
// using illegal test values will cause invalidity
HashMap<String, String> k = new HashMap<String, String>();
HashMap<String, String> theResult = ep.testEvaluateExpression(k);
ruleTest.getParameters().clear();
for (Map.Entry<String, String> entry : result.entrySet()) {
ParameterType parameterType = new ParameterType();
parameterType.setKey(entry.getKey());
parameterType.setValue(entry.getValue());
ruleTest.getParameters().add(parameterType);
}
// if (theResult.get("ruleValidation").equals("rule_valid") &&
// result.get("ruleValidation").equals("rule_invalid")) {
// result.put("ruleValidation", "rule_valid");
// result.put("ruleEvaluatesTo", resword.getString("test_rules_rule_fail") + " " +
// result.get("ruleValidationFailMessage"));
// result.remove("ruleValidationFailMessage");
// }
// Put on screen
// request.setAttribute("duration", yearsAndMonths.print(dur.toPeriod()));
RulesTestMessagesType messageType = new RulesTestMessagesType();
messageType.setKey("duration");
messageType.setValue(yearsAndMonths.print(dur.toPeriod()));
ruleTest.getRulesTestMessages().add(messageType);
return ruleTest;
}
