Java 类org.apache.commons.lang3.BooleanUtils 实例源码

@Override
public Object call(Element element, List<SyntaxNode> params) {
    if (params.size() == 0) {
        return false;
    }
    Object calc = params.get(0).calc(element);
    if (calc == null) {
        return false;
    }
    if (calc instanceof Boolean) {
        return calc;
    }
    if (calc instanceof String) {
        return BooleanUtils.toBoolean(calc.toString());
    }
    if (calc instanceof Integer) {
        return calc != 0;
    }
    if (calc instanceof Number) {
        return ((Number) calc).doubleValue() > 0D;
    }
    return false;
}

@RefreshScope
@Bean
public FilterRegistrationBean responseHeadersSecurityFilter() {
    final HttpWebRequestProperties.Header header = casProperties.getHttpWebRequest().getHeader();
    final Map<String, String> initParams = new HashMap<>();
    initParams.put("enableCacheControl", BooleanUtils.toStringTrueFalse(header.isCache()));
    initParams.put("enableXContentTypeOptions", BooleanUtils.toStringTrueFalse(header.isXcontent()));
    initParams.put("enableStrictTransportSecurity", BooleanUtils.toStringTrueFalse(header.isHsts()));
    initParams.put("enableXFrameOptions", BooleanUtils.toStringTrueFalse(header.isXframe()));
    initParams.put("enableXSSProtection", BooleanUtils.toStringTrueFalse(header.isXss()));
    final FilterRegistrationBean bean = new FilterRegistrationBean();
    bean.setFilter(new ResponseHeadersEnforcementFilter());
    bean.setUrlPatterns(Collections.singleton("/*"));
    bean.setInitParameters(initParams);
    bean.setName("responseHeadersSecurityFilter");
    bean.setAsyncSupported(true);
    return bean;

}

@RefreshScope
@Bean
public FilterRegistrationBean requestParameterSecurityFilter() {
    final Map<String, String> initParams = new HashMap<>();
    initParams.put(RequestParameterPolicyEnforcementFilter.PARAMETERS_TO_CHECK,
            casProperties.getHttpWebRequest().getParamsToCheck());
    initParams.put(RequestParameterPolicyEnforcementFilter.CHARACTERS_TO_FORBID, "none");
    initParams.put(RequestParameterPolicyEnforcementFilter.ALLOW_MULTI_VALUED_PARAMETERS,
            BooleanUtils.toStringTrueFalse(casProperties.getHttpWebRequest().isAllowMultiValueParameters()));
    initParams.put(RequestParameterPolicyEnforcementFilter.ONLY_POST_PARAMETERS,
            casProperties.getHttpWebRequest().getOnlyPostParams());

    final FilterRegistrationBean bean = new FilterRegistrationBean();
    bean.setFilter(new RequestParameterPolicyEnforcementFilter());
    bean.setUrlPatterns(Collections.singleton("/*"));
    bean.setName("requestParameterSecurityFilter");
    bean.setInitParameters(initParams);
    bean.setAsyncSupported(true);
    return bean;
}

@Override
protected Map<String, Object> getAttributesForSamlRegisteredService(final Map<String, Object> attributes,
                                                                    final SamlRegisteredService service,
                                                                    final ApplicationContext applicationContext,
                                                                    final SamlRegisteredServiceCachingMetadataResolver resolver,
                                                                    final SamlRegisteredServiceServiceProviderMetadataFacade facade,
                                                                    final EntityDescriptor entityDescriptor) {
    final Pattern pattern = RegexUtils.createPattern(this.entityIds);
    final Matcher matcher = pattern.matcher(entityDescriptor.getEntityID());

    LOGGER.debug("Creating pattern [{}] to match against entity id [{}]", pattern.pattern(), entityDescriptor.getEntityID());

    final boolean matched = fullMatch ? matcher.matches() : matcher.find();
    LOGGER.debug("Pattern [{}] matched against [{}]? [{}]", pattern.pattern(), entityDescriptor.getEntityID(),
            BooleanUtils.toStringYesNo(matched));

    if (matched) {
        return authorizeReleaseOfAllowedAttributes(attributes);
    }
    return new HashMap<>();
}

@Override
protected WebApplicationService buildInternal(final WebApplicationService service,
                                              final Map<String, String> parameters) {
    final RegisteredService registeredService = this.servicesManager.findServiceBy(service);
    RegisteredServiceAccessStrategyUtils.ensureServiceAccessIsAllowed(service, registeredService);
    final Map.Entry<String, RegisteredServiceProperty> property = registeredService.getProperties()
            .entrySet().stream()
            .filter(entry -> entry.getKey().equalsIgnoreCase(TokenConstants.PROPERTY_NAME_TOKEN_AS_RESPONSE)
                    && BooleanUtils.toBoolean(entry.getValue().getValue()))
            .distinct()
            .findFirst()
            .orElse(null);

    if (property == null) {
        return super.buildInternal(service, parameters);
    }

    final String jwt = generateToken(service, parameters);
    final TokenWebApplicationService jwtService =
            new TokenWebApplicationService(service.getId(), service.getOriginalUrl(), service.getArtifactId());
    jwtService.setFormat(service.getFormat());
    jwtService.setLoggedOutAlready(service.isLoggedOutAlready());
    parameters.put(CasProtocolConstants.PARAMETER_TICKET, jwt);
    return jwtService;
}

@Override
public boolean isSatisfiedBy(final Assertion assertion, final HttpServletRequest request) {
    LOGGER.debug("Is validation specification set to enforce [{}] protocol behavior? [{}]. Is assertion issued from a new login? [{}]",
            CasProtocolConstants.PARAMETER_RENEW,
            BooleanUtils.toStringYesNo(this.renew),
            BooleanUtils.toStringYesNo(assertion.isFromNewLogin()));

    boolean satisfied = isSatisfiedByInternal(assertion);
    if (!satisfied) {
        LOGGER.warn("[{}] is not internally satisfied by the produced assertion", getClass().getSimpleName());
        return false;
    }
    satisfied = !this.renew || assertion.isFromNewLogin();
    if (!satisfied) {
        LOGGER.warn("[{}] is to enforce the [{}] CAS protocol behavior, yet the assertion is not issued from a new login",
                getClass().getSimpleName(), CasProtocolConstants.PARAMETER_RENEW);
        return false;
    }
    LOGGER.debug("Validation specification is satisfied by the produced assertion");
    return true;
}

private void resolveModifier(
    final GenericAttributeValue<Boolean> attribute,
    final String methodName,
    final List<String> resultList
) {
    if (attribute == null) {
        return;
    }
    final Boolean value = BooleanUtils.toBooleanObject(attribute.getStringValue());
    if (value == null) {
        return;
    }
    if (value) {
        resultList.add(methodName);
    } else {
        resultList.add(methodName + "(false)");
    }

}

private SyntaxNode buildByTokenHolder(TokenHolder tokenHolder) {
    if (tokenHolder.tokenType == TokenType.Expression) {
        return new ExpressionParser(new StringFunctionTokenQueue(tokenHolder.data)).parse();
    }
    if (tokenHolder.tokenType == TokenType.Function) {
        return parseFunction(new StringFunctionTokenQueue(tokenHolder.data));
    }
    if (tokenHolder.tokenType == TokenType.String) {
        return new StringSyntaxNode(tokenHolder.data);
    }
    if (tokenHolder.tokenType == TokenType.Boolean) {
        return new BooleanSyntaxNode(BooleanUtils.toBoolean(tokenHolder.data));
    }
    if (tokenHolder.tokenType == TokenType.Number) {
        if (tokenHolder.data.contains(".")) {
            return new NumberSyntaxNode(NumberUtils.toDouble(tokenHolder.data));
        } else {
            return new NumberSyntaxNode(NumberUtils.toInt(tokenHolder.data));
        }
    }
    throw new IllegalStateException("unknown token type: " + tokenHolder.tokenType);
}

@Bean(name = ConfigConstant.NAME_DS_MASTER)
@Primary
@ConfigurationProperties(prefix = ConfigConstant.PREFIX_DS_MASTER)
public DataSource mafMasterDataSource() {
    logger.info("----- MAFIA master data source INIT -----");
    DruidDataSource ds = new DruidDataSource();
    try {
        ds.setFilters(env.getProperty("ds.filters"));
    } catch (SQLException e) {
        logger.warn("Data source set filters ERROR:", e);
    }
    ds.setMaxActive(NumberUtils.toInt(env.getProperty("ds.maxActive"), 90));
    ds.setInitialSize(NumberUtils.toInt(env.getProperty("ds.initialSize"), 10));
    ds.setMaxWait(NumberUtils.toInt(env.getProperty("ds.maxWait"), 60000));
    ds.setMinIdle(NumberUtils.toInt(env.getProperty("ds.minIdle"), 1));
    ds.setTimeBetweenEvictionRunsMillis(NumberUtils.toInt(env.getProperty("ds.timeBetweenEvictionRunsMillis"), 60000));
    ds.setMinEvictableIdleTimeMillis(NumberUtils.toInt(env.getProperty("ds.minEvictableIdleTimeMillis"), 300000));
    ds.setValidationQuery(env.getProperty("ds.validationQuery"));
    ds.setTestWhileIdle(BooleanUtils.toBoolean(env.getProperty("ds.testWhileIdle")));
    ds.setTestOnBorrow(BooleanUtils.toBoolean(env.getProperty("ds.testOnBorrow")));
    ds.setTestOnReturn(BooleanUtils.toBoolean(env.getProperty("ds.testOnReturn")));
    ds.setPoolPreparedStatements(BooleanUtils.toBoolean(env.getProperty("ds.poolPreparedStatements")));
    ds.setMaxOpenPreparedStatements(NumberUtils.toInt(env.getProperty("ds.maxOpenPreparedStatements"), 20));
    return ds;
}

@Bean(name = ConfigConstant.NAME_DS_SLAVE)
@ConfigurationProperties(prefix = ConfigConstant.PREFIX_DS_SLAVE)
public DataSource mafSlaveDataSource() {
    logger.info("----- MAFIA slave data source INIT -----");
    DruidDataSource ds = new DruidDataSource();
    try {
        ds.setFilters(env.getProperty("ds.filters"));
    } catch (SQLException e) {
        logger.warn("Data source set filters ERROR:", e);
    }
    ds.setMaxActive(NumberUtils.toInt(env.getProperty("ds.maxActive"), 90));
    ds.setInitialSize(NumberUtils.toInt(env.getProperty("ds.initialSize"), 10));
    ds.setMaxWait(NumberUtils.toInt(env.getProperty("ds.maxWait"), 60000));
    ds.setMinIdle(NumberUtils.toInt(env.getProperty("ds.minIdle"), 1));
    ds.setTimeBetweenEvictionRunsMillis(NumberUtils.toInt(env.getProperty("ds.timeBetweenEvictionRunsMillis"), 60000));
    ds.setMinEvictableIdleTimeMillis(NumberUtils.toInt(env.getProperty("ds.minEvictableIdleTimeMillis"), 300000));
    ds.setValidationQuery(env.getProperty("ds.validationQuery"));
    ds.setTestWhileIdle(BooleanUtils.toBoolean(env.getProperty("ds.testWhileIdle")));
    ds.setTestOnBorrow(BooleanUtils.toBoolean(env.getProperty("ds.testOnBorrow")));
    ds.setTestOnReturn(BooleanUtils.toBoolean(env.getProperty("ds.testOnReturn")));
    ds.setPoolPreparedStatements(BooleanUtils.toBoolean(env.getProperty("ds.poolPreparedStatements")));
    ds.setMaxOpenPreparedStatements(NumberUtils.toInt(env.getProperty("ds.maxOpenPreparedStatements"), 20));
    return ds;
}

/**
 * Creates instance of the adaptor.
 * @param def broker definition
 * @throws IllegalArgumentException if invalid broker definition
 */
public AgpInputBrokerDefinitionAdaptor(EntityDefinition def) throws InvalidDefinitionException {
  super(def);
  this.credAdaptor =new CredentialsDefinitionAdaptor(def);
  this.botsAdaptor = new BotsBrokerDefinitionAdaptor(def);
  if (StringUtils.trimToEmpty(def.getType()).isEmpty()) {
    def.setType(AgpInputConnector.TYPE);
  } else if (!AgpInputConnector.TYPE.equals(def.getType())) {
    throw new InvalidDefinitionException("Broker definition doesn't match");
  } else {
    try {
      hostUrl = new URL(get(P_HOST_URL));
    } catch (MalformedURLException ex) {
      throw new InvalidDefinitionException(String.format("Invalid %s: %s", P_HOST_URL,get(P_HOST_URL)), ex);
    }
    folderId = get(P_FOLDER_ID);
    emitXml = BooleanUtils.toBooleanDefaultIfNull(BooleanUtils.toBooleanObject(get(P_EMIT_XML)), true);
    emitJson = BooleanUtils.toBooleanDefaultIfNull(BooleanUtils.toBooleanObject(get(P_EMIT_JSON)), false);
  }
}

/**
 * Creates instance of the adaptor.
 * @param def broker definition
 */
public GptBrokerDefinitionAdaptor(EntityDefinition def) throws InvalidDefinitionException {
  super(def);
  this.credAdaptor = new CredentialsDefinitionAdaptor(def);
  this.botsAdaptor = new BotsBrokerDefinitionAdaptor(def);
  if (StringUtils.trimToEmpty(def.getType()).isEmpty()) {
    def.setType(GptConnector.TYPE);
  } else if (!GptConnector.TYPE.equals(def.getType())) {
    throw new InvalidDefinitionException("Broker definition doesn't match");
  } else {
    try {
      String sHostUrl = get(P_HOST_URL);
      if (sHostUrl!=null) {
        sHostUrl = sHostUrl.replaceAll("/*$", "/");
      }
      hostUrl = new URL(sHostUrl);
    } catch (MalformedURLException ex) {
      throw new InvalidDefinitionException(String.format("Invalid %s: %s", P_HOST_URL,get(P_HOST_URL)), ex);
    }
    index  = get(P_INDEX);
    emitXml = BooleanUtils.toBooleanDefaultIfNull(BooleanUtils.toBooleanObject(get(P_EMIT_XML)), true);
    emitJson = BooleanUtils.toBooleanDefaultIfNull(BooleanUtils.toBooleanObject(get(P_EMIT_JSON)), false);
  }
}

/**
 * Creates instance of the adaptor.
 * @param def broker definition
 * @throws InvalidDefinitionException if invalid broker definition
 */
public AgsBrokerDefinitionAdaptor(EntityDefinition def) throws InvalidDefinitionException {
  super(def);
  this.credAdaptor =new CredentialsDefinitionAdaptor(def);
  this.botsAdaptor = new BotsBrokerDefinitionAdaptor(def);
  if (StringUtils.trimToEmpty(def.getType()).isEmpty()) {
    def.setType(AgsConnector.TYPE);
  } else if (!AgsConnector.TYPE.equals(def.getType())) {
    throw new InvalidDefinitionException("Broker definition doesn't match");
  } else {
    try {
      hostUrl = new URL(get(P_HOST_URL));
    } catch (MalformedURLException ex) {
      throw new InvalidDefinitionException(String.format("Invalid %s: %s", P_HOST_URL,get(P_HOST_URL)), ex);
    }
    enableLayers = BooleanUtils.toBoolean(get(P_ENABLE_LAYERS));
    emitXml = BooleanUtils.toBooleanDefaultIfNull(BooleanUtils.toBooleanObject(get(P_EMIT_XML)), true);
    emitJson = BooleanUtils.toBooleanDefaultIfNull(BooleanUtils.toBooleanObject(get(P_EMIT_JSON)), false);
  }
}

@Override
public Boolean read(JsonReader in) throws IOException {
  JsonToken peek = in.peek();
  switch (peek) {
    case BOOLEAN:
      return in.nextBoolean();
    case NULL:
      in.nextNull();
      return null;
    case NUMBER:
      return BooleanUtils.toBoolean(in.nextInt());
    case STRING:
      return BooleanUtils.toBoolean(in.nextString());
    default:
      throw new JsonParseException("Expected BOOLEAN or NUMBER but was " + peek);
  }
}

protected <T> ResponseEntity<T> execute(String url,
                                        HttpMethod httpMethod,
                                        HttpEntity<?> httpEntity,
                                        ParameterizedTypeReference<T> typeReference,
                                        Map<String, String> uriVariables) {
    if (Objects.isNull(uriVariables)) {
        uriVariables = Maps.newHashMap();
    }

    if (BooleanUtils.isTrue(swallowException)) {
        try {
            return doExecute(url, httpMethod, httpEntity, typeReference, uriVariables);
        } catch (Exception e) {
            // camouflage exception
            log.error("http call failed, url [{}], http method [{}], http entity [{}], uri vars [{}]",
                    url, httpMethod, httpEntity, uriVariables, e);
            return doCamouflageException();
        }
    } else {
        return doExecute(url, httpMethod, httpEntity, typeReference, uriVariables);
    }
}

private TcAccount findOriginalTcAccount(@Nonnull String accountId, @Nonnull Boolean containsPassword) {
    checkNotNull(accountId);
    checkNotNull(containsPassword);
    TcAccountExample tcAccountExample = new TcAccountExample();
    tcAccountExample.setStartLine(0);
    tcAccountExample.setPageSize(1);
    tcAccountExample.createCriteria()
            .andIdEqualTo(accountId)
            .andDelectedEqualTo(false);
    List<TcAccount> tcAccounts = tcAccountMapper.selectByExample(tcAccountExample);
    if (CollectionUtils.isEmpty(tcAccounts)) {
        return null;
    }

    TcAccount tcAccount = tcAccounts.get(0);
    if (BooleanUtils.isFalse(containsPassword)) {
        tcAccount.setPassword(null);
    }

    return tcAccount;
}

public LoginModifierConfig(Map<String, String> params) throws ParametersException {
  this.loginPage = params.get(LOGIN_PAGE_PARAM);
  this.login = getParameter(params, LOGIN_PARAM, DEFAULT_LOGIN);
  this.password = getParameter(params, PASSWORD_PARAM, DEFAULT_PASSWORD);
  this.loginInputSelector = getParameter(params, LOGIN_INPUT_SELECTOR_PARAM,
      DEFAULT_LOGIN_INPUT_SELECTOR);
  this.passwordInputSelector = getParameter(params, PASSWORD_INPUT_SELECTOR_PARAM,
      DEFAULT_PASSWORD_INPUT_SELECTOR);
  this.submitButtonSelector = getParameter(params, SUBMIT_BUTTON_SELECTOR_PARAM,
      DEFAULT_SUBMIT_BUTTON_SELECTOR);
  this.loginTokenKey = getParameter(params, LOGIN_TOKEN_KEY_PARAM, DEFAULT_LOGIN_TOKEN);
  this.forceLogin = BooleanUtils.toBoolean(params.get(FORCE_LOGIN));
  this.delayBeforeLoginCheckOrReattempt = NumberUtils
      .toInt(getParameter(params, LOGIN_CHECK_TIMEOUT_PARAM, DEFAULT_CHECK_TIMEOUT_PARAM));
  this.retrialNumber = NumberUtils
      .toInt(getParameter(params, RETRIAL_NUMBER_PARAM, DEFAULT_RETRIAL_NUMBER));

  ParametersValidator.checkNotBlank(loginPage, "`login-page` parameter is mandatory");
  ParametersValidator.checkRange(delayBeforeLoginCheckOrReattempt, 0, 10000,
      "Timeout duration should be greater than 0 and less than 10 seconds");
  ParametersValidator
      .checkRange(retrialNumber, 1, Integer.MAX_VALUE, "Retrial number has to be at least 1");
}

/**
 * Determines the createIfNull property for a Collection or Map by getting it from the @CreateIfNull annotation.
 *
 * As fallback, it determines the boolean CreateIfNull property for a Collection or Map by getting it from the
 * conversion properties file using the CreateIfNull_ prefix. CreateIfNull_${property}=true|false
 *
 * @param parentClass     the Class which contains as a property the Map or Collection we are finding the key for.
 * @param property        the property of the Map or Collection for the given parent class
 * @param target          the target object
 * @param keyProperty     the keyProperty value
 * @param isIndexAccessed <tt>true</tt>, if the collection or map is accessed via index, <tt>false</tt> otherwise.
 * @return <tt>true</tt>, if the Collection or Map should be created, <tt>false</tt> otherwise.
 * @see ObjectTypeDeterminer#getKeyProperty(Class, String)
 */
public boolean shouldCreateIfNew(Class parentClass, String property, Object target, String keyProperty, boolean isIndexAccessed) {
    CreateIfNull annotation = getAnnotation(parentClass, property, CreateIfNull.class);
    if (annotation != null) {
        return annotation.value();
    }
    String configValue = (String) xworkConverter.getConverter(parentClass, CREATE_IF_NULL_PREFIX + property);
    //check if a value is in the config
    if (configValue != null) {
        return BooleanUtils.toBoolean(configValue);
    }

    //default values depend on target type
    //and whether this is accessed by an index
    //in the case of List
    return (target instanceof Map) || isIndexAccessed;
}

public void downloadForge(String minecraftVersion, List<ModLoader> modLoaders) {
    if (CollectionUtils.isEmpty(modLoaders) || Strings.isNullOrEmpty(minecraftVersion)) {
        log.debug("No Forge or Minecraft version found in manifest, skipping");
        return;
    }

    for (ModLoader modLoader : modLoaders) {
        if (BooleanUtils.isTrue(modLoader.getDownloadInstaller())) {
            log.debug("Downloading Forge installer version {}", modLoader.getId());
            downloadForgeFile(minecraftVersion, modLoader, true);
        }
        if (BooleanUtils.isTrue(modLoader.getDownloadUniversal())) {
            log.debug("Downloading Forge universal version {}", modLoader.getId());
            downloadForgeFile(minecraftVersion, modLoader, false);
        }
    }
}

/**
 * 处理异常。如果是 AJAX 请求，以 JSON 格式返回；如果是普通请求，dispatch 到错误页面。
 */
private Object handleException(Exception e, int status, String message, ServletWebRequest request) {
    Map<String, Object> errorResponse = getErrorResponse(e, message);

    // 如果开启 debug，则将 debug 标记写入 error response 中
    boolean isDebug = BooleanUtils.toBoolean(request.getParameter("debug"));
    logger.debug("Debug is {}", isDebug ? "on" : "off");
    if (isDebug) {
        errorResponse.put("debug", true);
    }

    // AJAX 请求需要手工指定 status
    if (isAjaxRequest(request)) {
        request.getResponse().setStatus(status);
        return errorResponse;
    }

    // 如果是普通请求，dispatch 到错误页面
    String exName = e.getClass().getName();
    String exView = StringUtils.defaultString(exceptionMappings.get(exName), defaultErrorView);
    return new ModelAndView(exView, errorResponse);
}

@Override
public void init(FilterConfig filterConfig) throws ServletException {
    String enableValue = filterConfig.getInitParameter("enable");
    logger.debug("Read enable param: {}", enableValue);
    if (!StringUtils.isEmpty(enableValue)) {
        isEnable = BooleanUtils.toBoolean(enableValue);
    }

    String patternRegex = filterConfig.getInitParameter("pattern");
    logger.debug("Read pattern param: {}", patternRegex);
    if (!StringUtils.isEmpty(patternRegex)) {
        uriPattern = Pattern.compile(filterConfig.getServletContext().getContextPath() + patternRegex);
    }

    String p3pValue = filterConfig.getInitParameter("p3pValue");
    logger.debug("Read p3pValue param: {}", p3pValue);
    if (!StringUtils.isEmpty(p3pValue)) {
        headerValue = p3pValue;
    }

    logger.info("{} initialized with {}", getClass(), isEnable ? "enable" : "disable");
}

/**
 * Return an expression for {@code entityPath.fieldName} (for Booleans) with
 * the {@code operator} or "equal" by default.
 * <p/>
 * Expr: {@code entityPath.fieldName eq searchObj}
 * 
 * @param entityPath
 * @param fieldName
 * @param searchObj
 * @param operator
 * @return
 */
public static <T> BooleanExpression createBooleanExpression(
        PathBuilder<T> entityPath, String fieldName, Object searchObj,
        String operator) {
    Boolean value = BooleanUtils.toBooleanObject((String) searchObj);
    if (value != null) {
        if (StringUtils.equalsIgnoreCase(operator, OPERATOR_GOE)) {
            return entityPath.getBoolean(fieldName).goe(value);
        }
        else if (StringUtils.equalsIgnoreCase(operator, "gt")) {
            return entityPath.getBoolean(fieldName).gt(value);
        }
        else if (StringUtils.equalsIgnoreCase(operator, OPERATOR_LOE)) {
            return entityPath.getBoolean(fieldName).loe(value);
        }
        else if (StringUtils.equalsIgnoreCase(operator, "lt")) {
            return entityPath.getBoolean(fieldName).lt(value);
        }
    }
    return entityPath.get(fieldName).eq(searchObj);
}

/**
 * Return where clause expression for {@code Boolean} fields by transforming
 * the given {@code searchStr} to {@code Boolean} before check its value.
 * <p/>
 * Expr: {@code entityPath.fieldName eq (TRUE | FALSE)}
 * 
 * @param entityPath Full path to entity and associations. For example:
 *        {@code Pet} , {@code Pet.owner}
 * @param fieldName Property name in the given entity path. For example:
 *        {@code weight} in {@code Pet} entity, {@code age} in
 *        {@code Pet.owner} entity.
 * @param searchStr the boolean value to find, may be null. Supported string
 *        are: si, yes, true, on, no, false, off
 * @return BooleanExpression
 */
public static <T> BooleanExpression createBooleanExpression(
        PathBuilder<T> entityPath, String fieldName, String searchStr) {
    if (StringUtils.isBlank(searchStr)) {
        return null;
    }

    Boolean value = null;

    // I18N: Spanish (normalize search value: trim start-end and lower case)
    if ("si".equals(StringUtils.trim(searchStr).toLowerCase())) {
        value = Boolean.TRUE;
    }
    else {
        value = BooleanUtils.toBooleanObject(searchStr);
    }

    // if cannot parse to boolean or null input
    if (value == null) {
        return null;
    }

    BooleanExpression expression = entityPath.getBoolean(fieldName).eq(
            value);
    return expression;
}

/**
 * {@inheritDoc}
 */
@Override
public <T> BooleanExpression createBooleanExpression(
        PathBuilder<T> entityPath, String fieldName, Object searchObj,
        String operator) {
    Boolean value = BooleanUtils.toBooleanObject((String) searchObj);
    if (value != null) {
        if (StringUtils.equalsIgnoreCase(operator, OPERATOR_GOE)) {
            return entityPath.getBoolean(fieldName).goe(value);
        }
        else if (StringUtils.equalsIgnoreCase(operator, "gt")) {
            return entityPath.getBoolean(fieldName).gt(value);
        }
        else if (StringUtils.equalsIgnoreCase(operator, OPERATOR_LOE)) {
            return entityPath.getBoolean(fieldName).loe(value);
        }
        else if (StringUtils.equalsIgnoreCase(operator, "lt")) {
            return entityPath.getBoolean(fieldName).lt(value);
        }
    }
    return entityPath.get(fieldName).eq(searchObj);
}

@Override
public void e() throws Exception {
    if (BooleanUtils.isTrue(clear)) {
        FileUtils.deleteDirectory(frontendDirectory);
        FileUtils.deleteDirectory(frontendWorkingDirectory);
    }
    generatNpmPackage(frontendWorkingDirectory);
    execMojo("com.github.eirslett", "frontend-maven-plugin",
            configuration(element(name("nodeVersion"), getVersion("node")),
                    element(name("npmVersion"), getVersion("npm")),
                    element(name("installDirectory"), frontendDirectory.getAbsolutePath())),
            "install-node-and-npm");
    execMojo("com.github.eirslett", "frontend-maven-plugin",
            configuration(element(name("arguments"), "install"),
                    element(name("installDirectory"), frontendDirectory.getAbsolutePath()),
                    element(name("workingDirectory"), frontendWorkingDirectory.getAbsolutePath())),
            "npm");
}

public static synchronized boolean createNamedPipe(final File file) {
    if (BooleanUtils.isFalse(namedPipeSupportedCached)) {
        return false;
    }
    try {
        //linux
        execCommand("mkfifo", file.getAbsolutePath());

    } catch (final Exception e) {
        //mac os
        try {
            execCommand("mknod", file.getAbsolutePath());
        } catch (final Exception e2) {
            return false;
        }
    }
    return true;
}

public AccessibilityReportConfiguration(Map<String, String> params) {
  if (params.containsKey(PARAM_SHOW_EXCLUDED)) {
    showExcluded = BooleanUtils.toBoolean(params.get(PARAM_SHOW_EXCLUDED));
  }

  if (params.containsKey(PARAM_IGNORE_NOTICE)) {
    ignoreNotice = BooleanUtils.toBoolean(params.get(PARAM_IGNORE_NOTICE));
  }

  String reportLevelString = StringUtils
      .defaultString(params.get(PARAM_REPORT_LEVEL), DEFAULT_REPORT_LEVEL);
  if (!ignoreNotice) {
    reportLevelString = IssueType.NOTICE.toString();
  }

  IssueType reportLevel;
  reportLevel = IssueType.valueOf(reportLevelString.toUpperCase());

  showNotice = IssueType.NOTICE.compareTo(reportLevel) <= 0;
  showWarning = IssueType.WARN.compareTo(reportLevel) <= 0;
}

/**
 * Creates the String to include SVN user and password in the command if necessary.
 * @return
 */
public static String createSvnCredentials() {
  boolean isSvnUsingCredentials =
      BooleanUtils.toBoolean( PropertiesUtil.getString("svn.enable.password.auth"));
  String credentials;
  if (isSvnUsingCredentials){
    String user = PropertiesUtil.getString("svn.username");
    String password = PropertiesUtil.getString("svn.password");
    credentials = String.format(SvnOperationsEnum.SVN_CREDENTIALS, user, password);
  } else {
    credentials = "";
  }
  return credentials;
}

@Override
public Object call(Element element, List<SyntaxNode> params) {
    if (element == null) {
        return false;
    }
    Object ret = params.get(0).calc(element);
    if (ret == null) {
        return false;
    }

    if (ret instanceof Number) {
        int i = ((Number) ret).intValue();
        return XpathUtil.getElIndexInSameTags(element) == i;
    }

    if (ret instanceof Boolean) {
        return ret;
    }

    if (ret instanceof CharSequence) {
        String s = ret.toString();
        Boolean booleanValue = BooleanUtils.toBooleanObject(s);
        if (booleanValue != null) {
            return booleanValue;
        }
        return StringUtils.isNotBlank(s);
    }

    log.warn("can not recognize predicate expression calc result:" + ret);
    return false;
}

private static String serializeRelyingPartyToken(final Element rpToken) {
    try {
        final StringWriter sw = new StringWriter();
        final Transformer t = TransformerFactory.newInstance().newTransformer();
        t.setOutputProperty(OutputKeys.OMIT_XML_DECLARATION, BooleanUtils.toStringYesNo(Boolean.TRUE));
        t.transform(new DOMSource(rpToken), new StreamResult(sw));
        return sw.toString();
    } catch (final TransformerException e) {
        throw Throwables.propagate(e);
    }
}

@Override
public boolean supports(final Service service) {
    final RegisteredService svc = this.servicesManager.findServiceBy(service);
    final boolean res = svc != null && service.getId().startsWith(this.callbackUrl);

    LOGGER.debug("Authentication request is{}identified as an OAuth request",
            BooleanUtils.toString(res, StringUtils.EMPTY, " not "));
    return res;
}

/**
 * Collect environment info with
 * details on the java and os deployment
 * versions.
 *
 * @param environment the environment
 * @param sourceClass the source class
 * @return environment info
 */
private String collectEnvironmentInfo(final Environment environment, final Class<?> sourceClass) {
    final Properties properties = System.getProperties();
    if (properties.containsKey("CAS_BANNER_SKIP")) {
        try (Formatter formatter = new Formatter()) {
            formatter.format("CAS Version: %s%n", CasVersion.getVersion());
            return formatter.toString();
        }
    }

    try (Formatter formatter = new Formatter()) {
        formatter.format("CAS Version: %s%n", CasVersion.getVersion());
        formatter.format("CAS Commit Id: %s%n", CasVersion.getSpecificationVersion());
        formatter.format("CAS Build Date/Time: %s%n", CasVersion.getDateTime());
        formatter.format("Spring Boot Version: %s%n", SpringBootVersion.getVersion());
        formatter.format("%s%n", LINE_SEPARATOR);

        formatter.format("System Date/Time: %s%n", LocalDateTime.now());
        formatter.format("System Temp Directory: %s%n", FileUtils.getTempDirectoryPath());
        formatter.format("%s%n", LINE_SEPARATOR);

        formatter.format("Java Home: %s%n", properties.get("java.home"));
        formatter.format("Java Vendor: %s%n", properties.get("java.vendor"));
        formatter.format("Java Version: %s%n", properties.get("java.version"));
        formatter.format("JCE Installed: %s%n", BooleanUtils.toStringYesNo(isJceInstalled()));
        formatter.format("%s%n", LINE_SEPARATOR);

        formatter.format("OS Architecture: %s%n", properties.get("os.arch"));
        formatter.format("OS Name: %s%n", properties.get("os.name"));
        formatter.format("OS Version: %s%n", properties.get("os.version"));
        formatter.format("%s%n", LINE_SEPARATOR);

        injectEnvironmentInfoIntoBanner(formatter, environment, sourceClass);

        return formatter.toString();
    }
}

@Override
public boolean matches(final CharSequence rawPassword, final String encodedPassword) {
    final String encodedRawPassword = StringUtils.isNotBlank(rawPassword) ? encode(rawPassword.toString()) : null;
    final boolean matched = StringUtils.equals(encodedRawPassword, encodedPassword);
    LOGGER.debug("Provided password does{}match the encoded password", BooleanUtils.toString(matched, StringUtils.EMPTY, " not "));
    return matched;
}

/**
 * 转换为Boolean类型
 * 'true', 'on', 'y', 't', 'yes' or '1' (case insensitive) will return true. Otherwise, false is returned.
 */
public static Boolean toBoolean(final Object val) {
    if (val == null) {
        return false;
    }
    return BooleanUtils.toBoolean(val.toString()) || "1".equals(val.toString());
}

public boolean saveUserSetting(UserSetting us) {
    String startCalendarStr = CalendarUtils.formatYMDHM(us.apptSearchRule.startCalendar);
    String endCalendarStr = us.apptSearchRule.endCalendar != null ? CalendarUtils.formatYMDHM(us.apptSearchRule.endCalendar) : "";
    String format = "INSERT INTO usersetting("
        + "username,password,examCode,countryCode,city,stateCode,type,startCalendar,endCalendar,"
        + "applyType,paramVoucherNumber,"
        + "paymentType,cardNumber,cardHoldersName,cardExpYear,cardExpMonth,cardSecCode,"
        + "searchSeatOnly,loopRequestIntervalMS)"
        + "VALUES('%s','%s','%s','%s','%s','%s',%d,'%s','%s',%d,'%s',%d,'%s','%s',%d,%d,'%s',%d,%d)";
    int rows = dbUtil.executeUpdate(
        String.format(format,
            us.user.username,
            us.user.password,
            us.examCode,
            us.testCentersCriteria.get("countryCode"),
            us.testCentersCriteria.get("city"),
            us.testCentersCriteria.get("stateCode"),
            us.apptSearchRule.type,
            startCalendarStr,
            endCalendarStr,
            us.applyType,
            us.paramVoucherNumber,
            us.creditCard.get("paymentType"),
            us.creditCard.get("cardNumber"),
            us.creditCard.get("cardHoldersName"),
            us.creditCard.get("cardExpYear"),
            us.creditCard.get("cardExpMonth"),
            us.creditCard.get("cardSecCode"),
            BooleanUtils.toInteger(us.searchSeatOnly),
            us.loopRequestIntervalMS));
    return rows > 0;
}

public boolean updateUserSettingByUid(UserSetting us) {
    String startCalendarStr = CalendarUtils.formatYMDHM(us.apptSearchRule.startCalendar);
    String endCalendarStr = us.apptSearchRule.endCalendar != null ? CalendarUtils.formatYMDHM(us.apptSearchRule.endCalendar) : "";
    String format = "UPDATE usersetting SET "
        + "username='%s',password='%s',"
        + "examCode='%s',countryCode='%s',city='%s',stateCode='%s',"
        + "type=%d,startCalendar='%s',endCalendar='%s',"
        + "applyType=%d,paramVoucherNumber='%s',"
        + "paymentType=%d,cardNumber='%s',cardHoldersName='%s',cardExpYear=%d,cardExpMonth=%d,cardSecCode='%s',"
        + "searchSeatOnly=%d,loopRequestIntervalMS=%d"
        + " WHERE uid=%d";
    return dbUtil.executeUpdate(
        String.format(format,
            us.user.username,
            us.user.password,
            us.examCode,
            us.testCentersCriteria.get("countryCode"),
            us.testCentersCriteria.get("city"),
            us.testCentersCriteria.get("stateCode"),
            us.apptSearchRule.type,
            startCalendarStr,
            endCalendarStr,
            us.applyType,
            us.paramVoucherNumber,
            us.creditCard.get("paymentType"),
            us.creditCard.get("cardNumber"),
            us.creditCard.get("cardHoldersName"),
            us.creditCard.get("cardExpYear"),
            us.creditCard.get("cardExpMonth"),
            us.creditCard.get("cardSecCode"),
            BooleanUtils.toInteger(us.searchSeatOnly),
            us.loopRequestIntervalMS,
            us.user.uid)) > 0;
}

@Override
public AlertsChannelConfiguration generateAlertsChannelConfiguration(NewRelicApi api) {
    EmailChannel emailChannel = (EmailChannel) channel;
    AlertsChannelConfiguration.AlertsChannelConfigurationBuilder builder = AlertsChannelConfiguration.builder();
    builder.recipients(emailChannel.getEmailAddress());
    if (BooleanUtils.isTrue(emailChannel.getIncludeJsonAttachment())) {
        builder.includeJsonAttachment(emailChannel.getIncludeJsonAttachment());
    }
    return builder.build();
}

private <T> boolean trimToSize(Boolean showAll, List<T> list, int userPaginationPreference) {
    boolean trimmed = false;
    if(!BooleanUtils.isTrue(showAll)) {
        if(list.size() > userPaginationPreference) {
            trimmed = true;
            list.subList(userPaginationPreference, list.size()).clear();
        }
    }
    return trimmed;
}

public void onFilterOperationsChange(final AjaxBehaviorEvent event) {
    final Boolean myOpsOnlyNegated = BooleanUtils.negate(this.isMyOperationsOnly());
    if (LOGGER.isDebugEnabled()) {
        LOGGER.debug(String.format(
                "onFilterOperationsChange(event=%s) triggered, reloading records with myOperationsFlag=%s", event,
                myOpsOnlyNegated));
    }
    this.loadOperationRecords(myOpsOnlyNegated);
}

/**
 * Save or update the given entity from the {@link QuoteInstanceEditionVo}. The
 * computed cost are recursively updated from the instance to the quote total
 * cost.
 */
private UpdatedCost saveOrUpdate(final ProvQuoteInstance entity, final QuoteInstanceEditionVo vo) {
    // Compute the unbound cost delta
    final int deltaUnbound = BooleanUtils.toInteger(vo.getMaxQuantity() == null) - BooleanUtils.toInteger(entity.isUnboundCost());

    // Check the associations and copy attributes to the entity
    final ProvQuote configuration = getQuoteFromSubscription(vo.getSubscription());
    entity.setConfiguration(configuration);
    final Subscription subscription = configuration.getSubscription();
    final String providerId = subscription.getNode().getRefined().getId();
    DescribedBean.copy(vo, entity);
    entity.setPrice(ipRepository.findOneExpected(vo.getPrice()));
    entity.setLocation(resource.findLocation(subscription.getId(), vo.getLocation()));
    entity.setUsage(Optional.ofNullable(vo.getUsage()).map(u -> resource.findConfigured(usageRepository, u)).orElse(null));
    entity.setOs(ObjectUtils.defaultIfNull(vo.getOs(), entity.getPrice().getOs()));
    entity.setRam(vo.getRam());
    entity.setCpu(vo.getCpu());
    entity.setConstant(vo.getConstant());
    entity.setEphemeral(vo.isEphemeral());
    entity.setInternet(vo.getInternet());
    entity.setMaxVariableCost(vo.getMaxVariableCost());
    entity.setMinQuantity(vo.getMinQuantity());
    entity.setMaxQuantity(vo.getMaxQuantity());

    resource.checkVisibility(entity.getPrice().getType(), providerId);
    checkConstraints(entity);
    checkOs(entity);

    // Update the unbound increment of the global quote
    configuration.setUnboundCostCounter(configuration.getUnboundCostCounter() + deltaUnbound);

    // Save and update the costs
    final UpdatedCost cost = newUpdateCost(entity);
    final Map<Integer, FloatingCost> storagesCosts = new HashMap<>();
    CollectionUtils.emptyIfNull(entity.getStorages())
            .forEach(s -> storagesCosts.put(s.getId(), addCost(s, storageResource::updateCost)));
    cost.setRelatedCosts(storagesCosts);
    cost.setTotalCost(toFloatingCost(entity.getConfiguration()));
    return cost;
}