Java RuleResult类代码示例

import org.passay.RuleResult; //导入依赖的package包/类
@Override
public boolean isValid(final String password, final ConstraintValidatorContext context) {
    final PasswordValidator validator = new PasswordValidator(singletonList(
        new LengthRule(8, 30)
        // More rules can be added to increase security
    ));

    final RuleResult result = validator.validate(new PasswordData(password));
    if (result.isValid()) {
        return true;
    }

    context.disableDefaultConstraintViolation();
    context.buildConstraintViolationWithTemplate(
        validator.getMessages(result).stream().collect(joining("\n"))
    ).addConstraintViolation();

    return false;
}
 

import org.passay.RuleResult; //导入依赖的package包/类
@Override
public boolean isValid(final String password, final ConstraintValidatorContext context) {
    final PasswordValidator validator = new PasswordValidator(Arrays.asList(new LengthRule(8, 30), new UppercaseCharacterRule(1), new DigitCharacterRule(1), new SpecialCharacterRule(1), new WhitespaceRule()));
    final RuleResult result = validator.validate(new PasswordData(password));
    if (result.isValid()) {
        return true;
    }
    context.disableDefaultConstraintViolation();
    context.buildConstraintViolationWithTemplate(Joiner.on("\n").join(validator.getMessages(result))).addConstraintViolation();
    return false;
}
 

import org.passay.RuleResult; //导入依赖的package包/类
@Override
public boolean isValid(final String password, final ConstraintValidatorContext context) {
    // @formatter:off
    final PasswordValidator validator = new PasswordValidator(Arrays.asList(
        new LengthRule(8, 30), 
        new UppercaseCharacterRule(1), 
        new DigitCharacterRule(1), 
        new SpecialCharacterRule(1), 
        new NumericalSequenceRule(3,false),
        new AlphabeticalSequenceRule(3,false),
        new QwertySequenceRule(3,false),
        new WhitespaceRule()));
    final RuleResult result = validator.validate(new PasswordData(password));
    if (result.isValid()) {
        return true;
    }
    context.disableDefaultConstraintViolation();
    context.buildConstraintViolationWithTemplate(Joiner.on(",").join(validator.getMessages(result))).addConstraintViolation();
    return false;
}
 

import org.passay.RuleResult; //导入依赖的package包/类
private boolean passwordComplexityCheck(String password){

		PasswordValidator validator = new PasswordValidator(Arrays.asList(
				new LengthRule(8,20),
				new UppercaseCharacterRule(1),
				new LowercaseCharacterRule(1),
				new DigitCharacterRule(1),
				new SpecialCharacterRule(2),
				new WhitespaceRule()
		));
		RuleResult result = validator.validate(new PasswordData(password));
		if(result.isValid()){
			return true;
		}
		else{
			for (String msg : validator.getMessages(result)) {
				Toast.makeText(this, msg,Toast.LENGTH_SHORT).show();
			}
			return false;
		}
	}
 

import org.passay.RuleResult; //导入依赖的package包/类
/**
 * In addition to determining whether the passwords are valid, this method also handles the ui
 * cues that let the user know what is wrong with their password. Maybe not the best instance
 * of the single responsibility principle, but it's simple enough in practice.
 *
 * @return True if the passwords entered are valid.
 */
private boolean validatePasswords() {
    boolean result = true;

    String newPassword = newPasswordField.getText();
    String matchingPassword = confirmPasswordField.getText();

    // Hide any already showing errors
    errorLabel.setVisible(false);
    lengthLabel.getStyleClass().remove("validationErrorText");
    specialCharLabel.getStyleClass().remove("validationErrorText");
    numberLabel.getStyleClass().remove("validationErrorText");
    mixedCaseLabel.getStyleClass().remove("validationErrorText");

    if(newPassword.isEmpty() || matchingPassword.isEmpty()) {
        errorLabel.setVisible(true);
        errorLabel.setText("Fields cannot be empty");
        result = false;
    }

    if(!newPassword.equals(matchingPassword)) {
        errorLabel.setVisible(true);
        errorLabel.setText("Passwords don't match");
        result = false;
    }

    RuleResult ruleResult = PasswordValidatorUtil.validator
            .validate(new PasswordData(newPassword));

    if(!ruleResult.isValid()) {
        result = false;
    }

    // Update the requirements labels
    for(RuleResultDetail d : ruleResult.getDetails()) {
        String errorCode = d.getErrorCode();
        switch(errorCode) {
            case "TOO_SHORT":
                lengthLabel.getStyleClass().add("validationErrorText");
                break;
            case "INSUFFICIENT_LOWERCASE":
            case "INSUFFICIENT_UPPERCASE":
                mixedCaseLabel.getStyleClass().add("validationErrorText");
                break;
            case "INSUFFICIENT_DIGIT":
                numberLabel.getStyleClass().add("validationErrorText");
                break;
            case "INSUFFICIENT_SPECIAL":
                specialCharLabel.getStyleClass().add("validationErrorText");
                break;
        }
    }

    return result;
}
 

import org.passay.RuleResult; //导入依赖的package包/类
/**
 * In addition to determining whether the passwords are valid, this method also handles the
 * UI cues that let the user know what is wrong with their password.
 *
 * @return True if the passwords entered are valid
 */
private boolean validatePasswords() {
    boolean result = true; // Innocent until proven guilty lol

    String password = passwordField.getText();
    String confirmPassword = confirmPasswordField.getText();

    // Hide any errors that are showing already
    errorLabel.setVisible(false);
    lengthLabel.getStyleClass().remove("validationErrorText");
    numAndSpecialCharLabel.getStyleClass().remove("validationErrorText");
    mixedCaseLabel.getStyleClass().remove("validationErrorText");

    // Check if there is any text written in the passwords fields
    if(password.isEmpty() || confirmPassword.isEmpty()) {
        errorLabel.setVisible(true);
        errorLabel.setText("Fields cannot be empty");
        result =   false;
    }

    // Check if password matches confirmation password
    if(!password.equals(confirmPassword)) {
        errorLabel.setVisible(true);
        errorLabel.setText("Passwords don't match");
        result = false;
    }

    RuleResult ruleResult = PasswordValidatorUtil.validator
            .validate(new PasswordData(password));

    // If the password is invalid, set the flag
    if(!ruleResult.isValid()) {
        result = false;
    }

    //Update the label requirements
    for(RuleResultDetail d : ruleResult.getDetails()) {
        String errorCode = d.getErrorCode();

        switch(errorCode) {
            case "TOO_SHORT":
                lengthLabel.getStyleClass().add("validationErrorText");
                break;
            case "INSUFFICIENT_LOWERCASE":
            case "INSUFFICIENT_UPPERCASE":
                mixedCaseLabel.getStyleClass().add("validationErrorText");
                break;
            case "INSUFFICIENT_DIGIT":
            case "INSUFFICIENT_SPECIAL":
                numAndSpecialCharLabel.getStyleClass()
                        .add("validationErrorText");
                break;
        }
    }
    return result;
}
 

import org.passay.RuleResult; //导入依赖的package包/类
@Override
public void validate(IValidatable<String> validatable) {
	String password = validatable.getValue();
	
	if (Boolean.FALSE.equals(propertyService.get(BasicApplicationCorePropertyIds.SECURITY_PASSWORD_VALIDATOR_ENABLED)) || !StringUtils.hasText(password)) {
		return;
	}
	
	User user = userModel != null ? userModel.getObject() : null;
	
	PasswordData passwordData = new PasswordData(password);
	
	List<Rule> passwordRules = Lists.newArrayList(securityManagementService.getOptions(typeDescriptor.getEntityClass()).getPasswordRules());
	
	if (user != null && StringUtils.hasText(user.getUserName())) {
		passwordData.setUsername(user.getUserName());
	} else {
		passwordRules.removeAll(Lists.newArrayList(Iterables.filter(passwordRules, UsernameRule.class)));
	}
	
	PasswordValidator validator = new PasswordValidator(passwordRules);
	RuleResult result = validator.validate(passwordData);
	
	boolean valid = true;
	if (!result.isValid()) {
		valid = false;
		for (RuleResultDetail detail : result.getDetails()) {
			if (RULES_CUSTOM_ERROR.contains(detail.getErrorCode())) {
				validatable.error(
						new ValidationError(this, detail.getErrorCode())
								.setVariables((Map<String, Object>) detail.getParameters())
				);
			}
		}
	}
	
	if (user != null
			&& securityManagementService.getOptions(user).isPasswordHistoryEnabled()
			&& user.getPasswordInformation().getHistory() != null
			&& !user.getPasswordInformation().getHistory().isEmpty()) {
		for (String historyPasswordHash : user.getPasswordInformation().getHistory()) {
			if (passwordEncoder.matches(password, historyPasswordHash)) {
				valid = false;
				validatable.error(
						new ValidationError(this, HISTORY_VIOLATION)
				);
				break;
			}
		}
	}
	
	if (!valid) {
		validatable.error(
				new ValidationError(this, COMMON_ERROR)
		);
	}
}
 

import org.passay.RuleResult; //导入依赖的package包/类
@Secured({"ROLE_ANONYMOUS"})
@Override
public RegisterUserResponse processService(
		final RegisterUserRequest serviceRequest) {

	final CreateApplicationEventRequest eventRequest = new CreateApplicationEventRequest();
	eventRequest.setEventGroup(ApplicationEventGroup.USER);
	eventRequest.setApplicationOperation(ApplicationOperationType.CREATE);
	eventRequest.setActionName(RegisterUserRequest.class.getSimpleName());
	eventRequest.setSessionId(serviceRequest.getSessionId());
	eventRequest.setElementId(serviceRequest.getEmail());

	final ApplicationConfiguration registeredUsersGetAdminConfig = applicationConfigurationService.checkValueOrLoadDefault("Registered User All get Role Admin", "Registered User All get Role Admin", ConfigurationGroup.AUTHORIZATION, RegisterUserService.class.getSimpleName(), "Register User Service", "Responsible for create of useraccounts", "registered.users.get.admin", "true");

	final UserAccount userNameExist = userDAO.findFirstByProperty(UserAccount_.username, serviceRequest.getUsername());
	final UserAccount userEmailExist = userDAO.findFirstByProperty(UserAccount_.email, serviceRequest.getEmail());

	final RuleResult passwordRuleResults = passwordValidator.validate(new PasswordData(serviceRequest.getUserpassword()));

	RegisterUserResponse response;
	if (userEmailExist == null && userNameExist == null && passwordRuleResults.isValid()) {
		final UserAccount userAccount = new UserAccount();
		userAccount.setCountry(serviceRequest.getCountry());
		userAccount.setEmail(serviceRequest.getEmail());
		userAccount.setUsername(serviceRequest.getUsername());
		userAccount.setUserId(UUID.randomUUID().toString());
		userAccount.setUserpassword(passwordEncoder.encode(userAccount.getUserId()+".uuid"+ serviceRequest.getUserpassword()));
		userAccount.setNumberOfVisits(1);
		userAccount.setUserType(serviceRequest.getUserType());
		userAccount.setCreatedDate(new Date());
		userDAO.persist(userAccount);

		if ("true".equals(registeredUsersGetAdminConfig.getPropertyValue())) {
			userAccount.setUserRole(UserRole.ADMIN);
		} else {
			userAccount.setUserRole(UserRole.USER);
		}

		final Collection<SimpleGrantedAuthority> authorities = new ArrayList<>();

		if (UserRole.ADMIN == userAccount.getUserRole()) {
			authorities.add(new SimpleGrantedAuthority("ROLE_ADMIN"));
		} else if (UserRole.USER == userAccount.getUserRole()) {
			authorities.add(new SimpleGrantedAuthority("ROLE_USER"));
		}

		SecurityContextHolder.getContext().setAuthentication(new UsernamePasswordAuthenticationToken(userAccount, userAccount.getUserpassword(), authorities));

		eventRequest.setUserId(userAccount.getUserId());
		response = new RegisterUserResponse(ServiceResult.SUCCESS);
	} else {
		response = new RegisterUserResponse(ServiceResult.FAILURE);
		if (passwordRuleResults.isValid()) {
			response.setErrorMessage(RegisterUserResponse.ErrorMessage.USER_ALREADY_EXIST.toString());
			eventRequest.setErrorMessage(RegisterUserResponse.ErrorMessage.USER_ALREADY_EXIST.toString());
		} else {
			final String errorMessage = passwordValidator.getMessages(passwordRuleResults).toString();
			response.setErrorMessage(errorMessage);
			eventRequest.setErrorMessage(errorMessage);
		}
	}

	eventRequest.setApplicationMessage(response.getResult().toString());
	createApplicationEventService.processService(eventRequest);
	LOGGER.info("Event: {}",eventRequest);
	return response;
}