コード例 #1
0
  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);
    }
  }
コード例 #2
0
  /**
   * 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);
    }
  }