protected void validateColumn(int rowNo, int colNo, Vector v, DBConnection conn) {
if (rowNo < 0 || rowNo > getRowCount() || colNo < 0 || colNo > getColumnCount()) return;
DSColumnDescriptor col = _desc.getColumn(colNo);
boolean remoteRules = false;
for (int i = 0; i < col.getRuleCount(); i++) {
try {
ValidationRule r = col.getRule(i);
if (r.getRuleType() == ValidationRule.TYPE_REMOTE) remoteRules = true;
else r.evaluateRule(this, rowNo, colNo, conn);
} catch (DataStoreException ex) {
ex.setRowNo(rowNo);
try {
ex.setColumn(getColumnName(colNo));
} catch (DataStoreException e) {
}
;
v.add(ex);
}
}
if (remoteRules) {
try {
DataStoreRow r = getDataStoreRow(rowNo, BUFFER_STANDARD);
r.getDSDataRow().setProxyRow(rowNo);
DataStoreException ex[] = getDataSourceProxy().validateRemoteRules(this, r, rowNo, colNo);
for (int i = 0; i < ex.length; i++) v.add(ex[i]);
} catch (DataStoreException dex) {
}
}
}
/**
* Gets the Set of period types found in a set of rules.
*
* <p>Note that that we have to get periodType from periodService, otherwise the ID will not be
* present.)
*
* @param rules validation rules of interest
* @return period types contained in those rules
*/
private Set<PeriodType> getPeriodTypesFromRules(Collection<ValidationRule> rules) {
Set<PeriodType> rulePeriodTypes = new HashSet<>();
for (ValidationRule rule : rules) {
rulePeriodTypes.add(periodService.getPeriodTypeByName(rule.getPeriodType().getName()));
}
return rulePeriodTypes;
}
public Collection<DataElement> getDataElementsInValidationRules() {
Set<DataElement> dataElements = new HashSet<DataElement>();
for (ValidationRule rule : getAllValidationRules()) {
dataElements.addAll(rule.getLeftSide().getDataElementsInExpression());
dataElements.addAll(rule.getRightSide().getDataElementsInExpression());
}
return dataElements;
}
/**
* Returns all validation rules referred to in the left and right side expressions of the given
* validation rules.
*
* @param validationRules the validation rules.
* @return a collection of data elements.
*/
private Set<DataElement> getDataElementsInValidationRules(
Collection<ValidationRule> validationRules) {
Set<DataElement> dataElements = new HashSet<DataElement>();
for (ValidationRule rule : validationRules) {
dataElements.addAll(rule.getLeftSide().getDataElementsInExpression());
dataElements.addAll(rule.getRightSide().getDataElementsInExpression());
}
return dataElements;
}
/** {@inheritDoc} */
public void validate(ModuleContext context, ModelObject mobj, IssueLogger logger) {
GBlock elem = (GBlock) mobj;
for (GActivity act : elem.getContents()) {
ValidationRule rule = ValidationRuleFactory.getValidationRule(act);
if (rule != null) {
rule.validate(context, act, logger);
}
}
}
/**
* Generate and send an alert message containing a list of validation results to a set of users.
*
* @param results results to put in this message
* @param users users to receive these results
* @param scheduledRunStart date/time when the scheduled run started
*/
private void sendAlertmessage(
SortedSet<ValidationResult> results, Set<User> users, Date scheduledRunStart) {
StringBuilder builder = new StringBuilder();
SimpleDateFormat dateTimeFormatter = new SimpleDateFormat("yyyy-MM-dd HH:mm");
Map<String, Integer> importanceCountMap = countResultsByImportanceType(results);
String subject =
"Alerts as of "
+ dateTimeFormatter.format(scheduledRunStart)
+ ": High "
+ (importanceCountMap.get("high") == null ? 0 : importanceCountMap.get("high"))
+ ", Medium "
+ (importanceCountMap.get("medium") == null ? 0 : importanceCountMap.get("medium"))
+ ", Low "
+ (importanceCountMap.get("low") == null ? 0 : importanceCountMap.get("low"));
// TODO use velocity template for message
for (ValidationResult result : results) {
ValidationRule rule = result.getValidationRule();
builder
.append(result.getOrgUnit().getName())
.append(" ")
.append(result.getPeriod().getName())
.append(
result.getAttributeOptionCombo().isDefault()
? ""
: " " + result.getAttributeOptionCombo().getName())
.append(LN)
.append(rule.getName())
.append(" (")
.append(rule.getImportance())
.append(") ")
.append(LN)
.append(rule.getLeftSide().getDescription())
.append(": ")
.append(result.getLeftsideValue())
.append(LN)
.append(rule.getRightSide().getDescription())
.append(": ")
.append(result.getRightsideValue())
.append(LN)
.append(LN);
}
log.info("Alerting users: " + users.size() + ", subject: " + subject);
messageService.sendMessage(subject, builder.toString(), null, users);
}
/**
* Returns all validation rules which have data elements assigned to it which are members of the
* given data set.
*
* @param dataSet the data set.
* @return all validation rules which have data elements assigned to it which are members of the
* given data set.
*/
private Collection<ValidationRule> getRelevantValidationRules(Set<DataElement> dataElements) {
Set<ValidationRule> relevantValidationRules = new HashSet<ValidationRule>();
Set<DataElement> validationRuleElements = new HashSet<DataElement>();
for (ValidationRule validationRule : getAllValidationRules()) {
validationRuleElements.clear();
validationRuleElements.addAll(validationRule.getLeftSide().getDataElementsInExpression());
validationRuleElements.addAll(validationRule.getRightSide().getDataElementsInExpression());
if (dataElements.containsAll(validationRuleElements)) {
relevantValidationRules.add(validationRule);
}
}
return relevantValidationRules;
}
@Override
protected IJsonNode evaluateSegment(final IJsonNode node) {
IJsonNode result = node;
for (EvaluationExpression expression : this.getExpressions()) {
if (expression instanceof ValidationRule) {
ValidationRule rule = (ValidationRule) expression;
result = rule.evaluate(result);
// we not longer skip evaluation if rule is violated
// if (!rule.validate(result)) {
// return rule.fix(result);
// }
} else if (expression instanceof FunctionCall) {
result = expression.evaluate(result);
}
}
return result;
}
@Override
public Collection<ValidationRule> getValidationTypeRulesForDataElements(
Set<DataElement> dataElements) {
Set<ValidationRule> rulesForDataElements = new HashSet<>();
for (ValidationRule validationRule : getAllValidationRules()) {
if (validationRule.getRuleType().equals(ValidationRule.RULE_TYPE_VALIDATION)) {
Set<DataElement> validationRuleElements = new HashSet<>();
validationRuleElements.addAll(validationRule.getLeftSide().getDataElementsInExpression());
validationRuleElements.addAll(validationRule.getRightSide().getDataElementsInExpression());
if (dataElements.containsAll(validationRuleElements)) {
rulesForDataElements.add(validationRule);
}
}
}
return rulesForDataElements;
}
public Collection<ValidationRule> getRelevantValidationRules(DataSet dataSet) {
Set<ValidationRule> relevantValidationRules = new HashSet<ValidationRule>();
Set<DataElementOperand> operands = dataEntryFormService.getOperandsInDataEntryForm(dataSet);
Set<DataElementOperand> validationRuleOperands = new HashSet<DataElementOperand>();
for (ValidationRule validationRule : getAllValidationRules()) {
validationRuleOperands.clear();
validationRuleOperands.addAll(
expressionService.getOperandsInExpression(validationRule.getLeftSide().getExpression()));
validationRuleOperands.addAll(
expressionService.getOperandsInExpression(validationRule.getRightSide().getExpression()));
if (operands.containsAll(validationRuleOperands)) {
relevantValidationRules.add(validationRule);
}
}
return relevantValidationRules;
}
/**
* Validates a collection of validation rules.
*
* @param period the period to validate for.
* @param source the source to validate for.
* @param validationRules the rules to validate.
* @param dataElementsInRules the data elements which are part of the rules expressions.
* @param constantMap the constants which are part of the rule expressions.
* @param currentSize the current number of validation violations.
* @returns a collection of rules that did not pass validation.
*/
private Collection<ValidationResult> validateInternal(
Period period,
OrganisationUnit unit,
Collection<ValidationRule> validationRules,
Set<DataElement> dataElementsInRules,
Map<String, Double> constantMap,
int currentSize) {
Map<DataElementOperand, Double> valueMap =
dataValueService.getDataValueMap(dataElementsInRules, period, unit);
final Collection<ValidationResult> validationViolations = new HashSet<ValidationResult>();
if (currentSize < MAX_VIOLATIONS) {
Double leftSide = null;
Double rightSide = null;
boolean violation = false;
for (final ValidationRule validationRule : validationRules) {
if (validationRule.getPeriodType() != null
&& validationRule.getPeriodType().equals(period.getPeriodType())) {
Operator operator = validationRule.getOperator();
leftSide =
expressionService.getExpressionValue(
validationRule.getLeftSide(), valueMap, constantMap, null);
if (leftSide != null || Operator.compulsory_pair.equals(operator)) {
rightSide =
expressionService.getExpressionValue(
validationRule.getRightSide(), valueMap, constantMap, null);
if (rightSide != null || Operator.compulsory_pair.equals(operator)) {
if (Operator.compulsory_pair.equals(operator)) {
violation =
(leftSide != null && rightSide == null)
|| (leftSide == null && rightSide != null);
} else if (leftSide != null && rightSide != null) {
violation = !expressionIsTrue(leftSide, operator, rightSide);
}
if (violation) {
validationViolations.add(
new ValidationResult(
period,
unit,
validationRule,
getRounded(zeroIfNull(leftSide), DECIMALS),
getRounded(zeroIfNull(rightSide), DECIMALS)));
}
}
}
}
}
}
return validationViolations;
}