java类javax.validation.constraints.AssertTrue的实例源码

@AssertTrue(message = "{error.to.sign.file.mandatory}")
public boolean isDocumentToSign() {
    return (documentToSign != null) && (!documentToSign.isEmpty());
}

@AssertTrue(message = "{error.signed.file.mandatory}")
public boolean isSignedFile() {
    return (signedFile != null) && (!signedFile.isEmpty());
}

@AssertTrue(message = "{error.signed.file.mandatory}")
public boolean isSignedFile() {
    return (signedFile != null) && (!signedFile.isEmpty());
}

@AssertTrue(message = "{error.to.sign.files.mandatory}")
public boolean isDocumentsToSign() {
    return Utils.isCollectionNotEmpty(documentsToSign);
}

@AssertTrue(message = "{error.certificate.mandatory}")
public boolean isCertificateFile() {
    return (certificateFile != null) && (!certificateFile.isEmpty());
}

@AssertTrue
public boolean isDataCorrect() {
    return type.equals("current") || !date.isEmpty();
}

@AssertTrue(message="Confirm password should match")
public boolean isValid() {
    return this.password.equals(this.cpassword);
}

@SuppressWarnings("unchecked")
public static <T extends Annotation> MinijaxConstraintDescriptor<T> build(final AnnotatedType annotatedType, final T annotation) {
    final Constraint constraint = annotation.annotationType().getAnnotation(Constraint.class);
    if (constraint == null) {
        return null;
    }

    final Class<?> valueClass = ReflectionUtils.getRawType(annotatedType);
    final Class<?> annotationClass = annotation.annotationType();

    if (constraint.validatedBy().length > 0) {
        return buildDeclaredValidator(annotation, constraint.validatedBy()[0]);

    } else if (annotationClass == AssertFalse.class) {
        return (MinijaxConstraintDescriptor<T>) buildAssertFalseValidator((AssertFalse) annotation, valueClass);

    } else if (annotationClass == AssertTrue.class) {
        return (MinijaxConstraintDescriptor<T>) buildAssertTrueValidator((AssertTrue) annotation, valueClass);

    } else if (annotationClass == Max.class) {
        return (MinijaxConstraintDescriptor<T>) buildMaxValidator((Max) annotation, valueClass);

    } else if (annotationClass == Min.class) {
        return (MinijaxConstraintDescriptor<T>) buildMinValidator((Min) annotation, valueClass);

    } else if (annotationClass == NotBlank.class) {
        return (MinijaxConstraintDescriptor<T>) buildNotBlankValidator((NotBlank) annotation, valueClass);

    } else if (annotationClass == NotEmpty.class) {
        return (MinijaxConstraintDescriptor<T>) buildNotEmptyValidator((NotEmpty) annotation, valueClass);

    } else if (annotationClass == NotNull.class) {
        return (MinijaxConstraintDescriptor<T>) buildNotNullValidator((NotNull) annotation);

    } else if (annotationClass == Pattern.class) {
        return (MinijaxConstraintDescriptor<T>) buildPatternValidator((Pattern) annotation, valueClass);

    } else if (annotationClass == Size.class) {
        return (MinijaxConstraintDescriptor<T>) buildSizeValidator((Size) annotation, valueClass);

    } else {
        throw new ValidationException("Unrecognized constraint annotation: " + annotation);
    }
}

@AssertTrue
public boolean isRegistered() {
    return isRegistered;
}

@AssertTrue
public boolean isRegistered() {
    return isRegistered;
}