Java ValidationUtils.isLessThanOrEqual方法代碼示例

import org.kuali.rice.krad.datadictionary.validation.ValidationUtils; //導入方法依賴的package包/類
/**
 * checks whether the value provided is in the range specified by inclusiveMax and exclusiveMin
 *
 * @param result a holder for any already run validation results
 * @param value the value to check
 * @param inclusiveMax the maximum value of the attribute
 * @param inclusiveMaxText the string representation of inclusiveMax
 * @param exclusiveMin the minimum value of the attribute
 * @param exclusiveMinText the string representation of exclusiveMin
 * @param attributeValueReader provides access to the attribute being validated
 * @return the passed in result, updated with the results of the range check
 */
private <T> ConstraintValidationResult isInRange(DictionaryValidationResult result, T value,
        Comparable<T> inclusiveMax, String inclusiveMaxText, Comparable<T> exclusiveMin, String exclusiveMinText,
        AttributeValueReader attributeValueReader) {
    // What we want to know is that the maximum value is greater than or equal to the number passed (the number can be equal to the max, i.e. it's 'inclusive')
    Result lessThanMax = ValidationUtils.isLessThanOrEqual(value, inclusiveMax);
    // On the other hand, since the minimum is exclusive, we just want to make sure it's less than the number (the number can't be equal to the min, i.e. it's 'exclusive')
    Result greaterThanMin = ValidationUtils.isGreaterThan(value, exclusiveMin);

    // It's okay for one end of the range to be undefined - that's not an error. It's only an error if one of them is actually invalid. 
    if (lessThanMax != Result.INVALID && greaterThanMin != Result.INVALID) {
        // Of course, if they're both undefined then we didn't actually have a real constraint
        if (lessThanMax == Result.UNDEFINED && greaterThanMin == Result.UNDEFINED) {
            return result.addNoConstraint(attributeValueReader, CONSTRAINT_NAME);
        }

        // In this case, we've succeeded
        return result.addSuccess(attributeValueReader, CONSTRAINT_NAME);
    }

    // If both comparisons happened then if either comparison failed we can show the end user the expected range on both sides.
    if (lessThanMax != Result.UNDEFINED && greaterThanMin != Result.UNDEFINED) {
        return result.addError(RANGE_KEY, attributeValueReader, CONSTRAINT_NAME,
                RiceKeyConstants.ERROR_OUT_OF_RANGE, exclusiveMinText, inclusiveMaxText);
    }
    // If it's the max comparison that fails, then just tell the end user what the max can be
    else if (lessThanMax == Result.INVALID) {
        return result.addError(MAX_INCLUSIVE_KEY, attributeValueReader, CONSTRAINT_NAME,
                RiceKeyConstants.ERROR_INCLUSIVE_MAX, inclusiveMaxText);
    }
    // Otherwise, just tell them what the min can be
    else {
        return result.addError(MIN_EXCLUSIVE_KEY, attributeValueReader, CONSTRAINT_NAME,
                RiceKeyConstants.ERROR_EXCLUSIVE_MIN, exclusiveMinText);
    }
}
 

import org.kuali.rice.krad.datadictionary.validation.ValidationUtils; //導入方法依賴的package包/類
/**
 * checks whether the value provided is in the range specified by inclusiveMax and exclusiveMin
 *
 * @param - a holder for any already run validation results
 * @param value - the value to check
 * @param inclusiveMax - the maximum value of the attribute
 * @param inclusiveMaxText - the string representation of inclusiveMax
 * @param exclusiveMin -  the minimum value of the attribute
 * @param exclusiveMinText - the string representation of exclusiveMin
 * @param attributeValueReader - provides access to the attribute being validated
 * @return the passed in result, updated with the results of the range check
 */
private <T> ConstraintValidationResult isInRange(DictionaryValidationResult result, T value,
        Comparable<T> inclusiveMax, String inclusiveMaxText, Comparable<T> exclusiveMin, String exclusiveMinText,
        AttributeValueReader attributeValueReader) {
    // What we want to know is that the maximum value is greater than or equal to the number passed (the number can be equal to the max, i.e. it's 'inclusive')
    Result lessThanMax = ValidationUtils.isLessThanOrEqual(value, inclusiveMax);
    // On the other hand, since the minimum is exclusive, we just want to make sure it's less than the number (the number can't be equal to the min, i.e. it's 'exclusive')
    Result greaterThanMin = ValidationUtils.isGreaterThan(value, exclusiveMin);

    // It's okay for one end of the range to be undefined - that's not an error. It's only an error if one of them is actually invalid. 
    if (lessThanMax != Result.INVALID && greaterThanMin != Result.INVALID) {
        // Of course, if they're both undefined then we didn't actually have a real constraint
        if (lessThanMax == Result.UNDEFINED && greaterThanMin == Result.UNDEFINED) {
            return result.addNoConstraint(attributeValueReader, CONSTRAINT_NAME);
        }

        // In this case, we've succeeded
        return result.addSuccess(attributeValueReader, CONSTRAINT_NAME);
    }

    // If both comparisons happened then if either comparison failed we can show the end user the expected range on both sides.
    if (lessThanMax != Result.UNDEFINED && greaterThanMin != Result.UNDEFINED) {
        return result.addError(RANGE_KEY, attributeValueReader, CONSTRAINT_NAME,
                RiceKeyConstants.ERROR_OUT_OF_RANGE, exclusiveMinText, inclusiveMaxText);
    }
    // If it's the max comparison that fails, then just tell the end user what the max can be
    else if (lessThanMax == Result.INVALID) {
        return result.addError(MAX_INCLUSIVE_KEY, attributeValueReader, CONSTRAINT_NAME,
                RiceKeyConstants.ERROR_INCLUSIVE_MAX, inclusiveMaxText);
    }
    // Otherwise, just tell them what the min can be
    else {
        return result.addError(MIN_EXCLUSIVE_KEY, attributeValueReader, CONSTRAINT_NAME,
                RiceKeyConstants.ERROR_EXCLUSIVE_MIN, exclusiveMinText);
    }
}
 

import org.kuali.rice.krad.datadictionary.validation.ValidationUtils; //導入方法依賴的package包/類
protected ConstraintValidationResult processSingleCollectionSizeConstraint(DictionaryValidationResult result,
        Collection<?> collection, CollectionSizeConstraint constraint,
        AttributeValueReader attributeValueReader) throws AttributeValidationException {
    Integer sizeOfCollection = new Integer(0);
    if (collection != null) {
        sizeOfCollection = Integer.valueOf(collection.size());
    }

    Integer maxOccurances = constraint.getMaximumNumberOfElements();
    Integer minOccurances = constraint.getMinimumNumberOfElements();

    Result lessThanMax = ValidationUtils.isLessThanOrEqual(sizeOfCollection, maxOccurances);
    Result greaterThanMin = ValidationUtils.isGreaterThanOrEqual(sizeOfCollection, minOccurances);

    // It's okay for one end of the range to be undefined - that's not an error. It's only an error if one of them is invalid
    if (lessThanMax != Result.INVALID && greaterThanMin != Result.INVALID) {
        // Of course, if they're both undefined then we didn't actually have a real constraint
        if (lessThanMax == Result.UNDEFINED && greaterThanMin == Result.UNDEFINED) {
            return result.addNoConstraint(attributeValueReader, CONSTRAINT_NAME);
        }

        // In this case, we've succeeded
        return result.addSuccess(attributeValueReader, CONSTRAINT_NAME);
    }

    String maxErrorParameter = maxOccurances != null ? maxOccurances.toString() : null;
    String minErrorParameter = minOccurances != null ? minOccurances.toString() : null;

    // If both comparisons happened then if either comparison failed we can show the end user the expected range on both sides.
    if (lessThanMax != Result.UNDEFINED && greaterThanMin != Result.UNDEFINED) {
        return result.addError(attributeValueReader, CONSTRAINT_NAME, RiceKeyConstants.ERROR_QUANTITY_RANGE,
                minErrorParameter, maxErrorParameter);
    }
    // If it's the max comparison that fails, then just tell the end user what the max can be
    else if (lessThanMax == Result.INVALID) {
        return result.addError(attributeValueReader, CONSTRAINT_NAME, RiceKeyConstants.ERROR_MAX_OCCURS,
                maxErrorParameter);
    }
    // Otherwise, just tell them what the min can be
    else {
        return result.addError(attributeValueReader, CONSTRAINT_NAME, RiceKeyConstants.ERROR_MIN_OCCURS,
                minErrorParameter);
    }

    // Obviously the last else above is unnecessary, since anything after it is dead code, but keeping it seems clearer than dropping it
}
 

import org.kuali.rice.krad.datadictionary.validation.ValidationUtils; //導入方法依賴的package包/類
protected ConstraintValidationResult validateLength(DictionaryValidationResult result, String value,
        LengthConstraint constraint, AttributeValueReader attributeValueReader) throws IllegalArgumentException {
    Integer valueLength = Integer.valueOf(value.length());

    Integer maxLength = constraint.getMaxLength();
    Integer minLength = constraint.getMinLength();

    Result lessThanMax = ValidationUtils.isLessThanOrEqual(valueLength, maxLength);
    Result greaterThanMin = ValidationUtils.isGreaterThanOrEqual(valueLength, minLength);

    // It's okay for one end of the range to be undefined - that's not an error. It's only an error if one of them is invalid 
    if (lessThanMax != Result.INVALID && greaterThanMin != Result.INVALID) {
        // Of course, if they're both undefined then we didn't actually have a real constraint
        if (lessThanMax == Result.UNDEFINED && greaterThanMin == Result.UNDEFINED) {
            return result.addNoConstraint(attributeValueReader, CONSTRAINT_NAME);
        }

        // In this case, we've succeeded
        return result.addSuccess(attributeValueReader, CONSTRAINT_NAME);
    }

    String maxErrorParameter = maxLength != null ? maxLength.toString() : null;
    String minErrorParameter = minLength != null ? minLength.toString() : null;

    // If both comparisons happened then if either comparison failed we can show the end user the expected range on both sides.
    if (lessThanMax != Result.UNDEFINED && greaterThanMin != Result.UNDEFINED) {
        return result.addError(RANGE_KEY, attributeValueReader, CONSTRAINT_NAME,
                RiceKeyConstants.ERROR_OUT_OF_RANGE, minErrorParameter, maxErrorParameter);
    }
    // If it's the max comparison that fails, then just tell the end user what the max can be
    else if (lessThanMax == Result.INVALID) {
        return result.addError(MAX_LENGTH_KEY, attributeValueReader, CONSTRAINT_NAME,
                RiceKeyConstants.ERROR_INCLUSIVE_MAX, maxErrorParameter);
    }
    // Otherwise, just tell them what the min can be
    else {
        return result.addError(MIN_LENGTH_KEY, attributeValueReader, CONSTRAINT_NAME,
                RiceKeyConstants.ERROR_EXCLUSIVE_MIN, minErrorParameter);
    }

}