Example usage for org.springframework.beans BeanWrapperImpl isReadableProperty

List of usage examples for org.springframework.beans BeanWrapperImpl isReadableProperty

  1. HOME
  2. Java
  3. org.springframework
  4. org.springframework.beans.*
  5. BeanWrapperImpl
  6. isReadableProperty

Introduction

In this page you can find the example usage for org.springframework.beans BeanWrapperImpl isReadableProperty.

Prototype

@Override
    public boolean isReadableProperty(String propertyName)

Source Link

Usage

From source file:io.spring.initializr.generator.CommandLineHelpGenerator.java

protected Map<String, Object> buildParametersDescription(InitializrMetadata metadata) {
    Map<String, Object> result = new LinkedHashMap<>();
    BeanWrapperImpl wrapper = new BeanWrapperImpl(metadata);
    for (PropertyDescriptor descriptor : wrapper.getPropertyDescriptors()) {
        Object value = wrapper.getPropertyValue(descriptor.getName());
        BeanWrapperImpl nested = new BeanWrapperImpl(value);
        if (nested.isReadableProperty("description") && nested.isReadableProperty("id")) {
            result.put((String) nested.getPropertyValue("id"), nested.getPropertyValue("description"));
        }//w w w  .j  a v  a 2 s .  c  om
    }
    result.put("applicationName", "application name");
    result.put("baseDir", "base directory to create in the archive");
    return result;
}

From source file:org.springjutsu.validation.ValidationEvaluationContext.java

/**
 * Responsible for discovering the path-described model which
 * is to be validated by the current rule. This path may contain
 * EL, and if it does, we delegate to @link(#resolveEL(String))
 * to resolve that EL.//from   w w  w.ja v  a  2s .c  o m
 * @param rule The rule for which to resolve the model
 * @return the resolved rule model
 */
protected Object resolveRuleModel(ValidationRule rule) {
    Object result = null;
    if (rule.getPath() == null || rule.getPath().isEmpty()) {
        return getRootModel();
    }
    // TODO / Note to self: the expression is actually the rule path,
    // which at this point has already been localized by the nested path
    // via rule cloning, so long as the rule path didn't contain EL
    if (PathUtils.containsEL(rule.getPath())) {
        result = spelResolver.resolveSPELString(rule.getPath());
    } else {
        BeanWrapperImpl beanWrapper = new BeanWrapperImpl(getRootModel());
        String localizedRulePath = localizePath(rule.getPath());
        // TODO: Why is this check here?
        // Under what circumstances did we want this to return null
        // instead of throwing an exception?
        if (beanWrapper.isReadableProperty(localizedRulePath)) {
            result = beanWrapper.getPropertyValue(localizedRulePath);
        }
    }
    return result;
}

From source file:org.gvnix.web.datatables.util.DatatablesUtils.java

/**
 * Populate a {@link DataSet} from given entity list.
 * <p/>/*from   w  w  w .  ja  va  2s  .  co m*/
 * Field values will be converted to String using given
 * {@link ConversionService} and Date fields will be converted to Date using
 * {@link DateFormat} with given date patterns.
 * 
 * @param entities List of T entities to convert to Datatables data
 * @param pkFieldName The T entity field that contains the PK
 * @param totalRecords Total amount of records
 * @param totalDisplayRecords Amount of records found
 * @param columns {@link ColumnDef} list
 * @param datePatterns Patterns to convert Date fields to String. The Map
 *        contains one pattern for each entity Date field keyed by field
 *        name. For Roo compatibility the key could follow the pattern
 *        {@code uncapitalize( ENTITY ) + "_" + lower_case( FIELD ) + "_date_format"}
 *        too
 * @param conversionService
 * @return
 */
public static <T> DataSet<Map<String, String>> populateDataSet(List<T> entities, String pkFieldName,
        long totalRecords, long totalDisplayRecords, List<ColumnDef> columns, Map<String, Object> datePatterns,
        ConversionService conversionService) {

    // Check arguments aren't null
    Assert.notNull(pkFieldName);
    Assert.notNull(columns);
    Assert.notNull(conversionService);

    // Map of data rows
    List<Map<String, String>> rows = new ArrayList<Map<String, String>>(entities.size());

    if (CollectionUtils.isEmpty(entities)) {
        return new DataSet<Map<String, String>>(rows, 0l, 0l);
    }

    // If null, create empty Map to avoid control code overload
    if (CollectionUtils.isEmpty(datePatterns)) {
        datePatterns = new HashMap<String, Object>();
    }
    Map<String, SimpleDateFormat> dateFormatters = new HashMap<String, SimpleDateFormat>(datePatterns.size());

    // Prepare required fields
    Set<String> fields = new HashSet<String>();
    fields.add(pkFieldName);

    // Add fields from request
    for (ColumnDef colum : columns) {
        fields.add(colum.getName());
    }

    BeanWrapperImpl entityBean = null;
    String valueStr = null;
    // Populate each row, note a row is a Map containing
    // fieldName = fieldValue
    for (T entity : entities) {
        Map<String, String> row = new HashMap<String, String>(fields.size());
        if (entityBean == null) {
            entityBean = new BeanWrapperImpl(entity);
        } else {
            entityBean.setWrappedInstance(entity);
        }
        for (String fieldName : fields) {

            String unescapedFieldName = unescapeDot(fieldName);

            // check if property exists (trace it else)
            if (!entityBean.isReadableProperty(unescapedFieldName)) {
                if (LOGGER.isTraceEnabled()) {
                    LOGGER.trace("Property [{}] not fond in bean {} [{}]", unescapedFieldName,
                            entity.getClass().getSimpleName(), entity);
                }
                row.put(fieldName, "");
                continue;
            }

            // Convert field value to string
            valueStr = convertFieldValueToString(datePatterns, dateFormatters, conversionService, entityBean,
                    entity, fieldName, unescapedFieldName);
            row.put(fieldName, valueStr);

            // Set PK value as DT_RowId
            // Note when entity has composite PK Roo generates the need
            // convert method and adds it to ConversionService, so
            // when processed field is the PK the valueStr is the
            // composite PK instance marshalled to JSON notation and
            // Base64 encoded
            if (pkFieldName.equalsIgnoreCase(fieldName)) {
                row.put("DT_RowId", valueStr);
            }
        }
        rows.add(row);
    }
    DataSet<Map<String, String>> dataSet = new DataSet<Map<String, String>>(rows, totalRecords,
            totalDisplayRecords);
    return dataSet;
}

From source file:io.spring.initializr.generator.ProjectGenerator.java

/**
 * Resolve the specified {@link ProjectRequest} and return the model to use to
 * generate the project/*w  w w.j a  v a  2  s  . c  o m*/
 * @param originalRequest the request to handle
 * @return a model for that request
 */
protected Map<String, Object> resolveModel(ProjectRequest originalRequest) {
    Assert.notNull(originalRequest.getBootVersion(), "boot version must not be null");
    Map<String, Object> model = new LinkedHashMap<>();
    InitializrMetadata metadata = metadataProvider.get();

    ProjectRequest request = requestResolver.resolve(originalRequest, metadata);

    // request resolved so we can log what has been requested
    List<Dependency> dependencies = request.getResolvedDependencies();
    List<String> dependencyIds = dependencies.stream().map(Dependency::getId).collect(Collectors.toList());
    log.info("Processing request{type=" + request.getType() + ", dependencies=" + dependencyIds);

    if (isWar(request)) {
        model.put("war", true);
    }

    if (isMavenBuild(request)) {
        model.put("mavenBuild", true);
        ParentPom parentPom = metadata.getConfiguration().getEnv().getMaven()
                .resolveParentPom(request.getBootVersion());
        if (parentPom.isIncludeSpringBootBom() && !request.getBoms().containsKey("spring-boot")) {
            request.getBoms().put("spring-boot",
                    metadata.createSpringBootBom(request.getBootVersion(), "spring-boot.version"));
        }

        model.put("mavenParentGroupId", parentPom.getGroupId());
        model.put("mavenParentArtifactId", parentPom.getArtifactId());
        model.put("mavenParentVersion", parentPom.getVersion());
        model.put("includeSpringBootBom", parentPom.isIncludeSpringBootBom());
    }

    model.put("repositoryValues", request.getRepositories().entrySet());
    if (!request.getRepositories().isEmpty()) {
        model.put("hasRepositories", true);
    }

    List<BillOfMaterials> resolvedBoms = request.getBoms().values().stream()
            .sorted(Comparator.comparing(BillOfMaterials::getOrder)).collect(Collectors.toList());
    model.put("resolvedBoms", resolvedBoms);
    ArrayList<BillOfMaterials> reversedBoms = new ArrayList<>(resolvedBoms);
    Collections.reverse(reversedBoms);
    model.put("reversedBoms", reversedBoms);

    model.put("compileDependencies", filterDependencies(dependencies, Dependency.SCOPE_COMPILE));
    model.put("runtimeDependencies", filterDependencies(dependencies, Dependency.SCOPE_RUNTIME));
    model.put("compileOnlyDependencies", filterDependencies(dependencies, Dependency.SCOPE_COMPILE_ONLY));
    model.put("providedDependencies", filterDependencies(dependencies, Dependency.SCOPE_PROVIDED));
    model.put("testDependencies", filterDependencies(dependencies, Dependency.SCOPE_TEST));

    request.getBoms().forEach((k, v) -> {
        if (v.getVersionProperty() != null) {
            request.getBuildProperties().getVersions().computeIfAbsent(v.getVersionProperty(),
                    key -> v::getVersion);
        }
    });

    Map<String, String> versions = new LinkedHashMap<>();
    model.put("buildPropertiesVersions", versions.entrySet());
    request.getBuildProperties().getVersions().forEach((k, v) -> versions.put(k, v.get()));
    Map<String, String> gradle = new LinkedHashMap<>();
    model.put("buildPropertiesGradle", gradle.entrySet());
    request.getBuildProperties().getGradle().forEach((k, v) -> gradle.put(k, v.get()));
    Map<String, String> maven = new LinkedHashMap<>();
    model.put("buildPropertiesMaven", maven.entrySet());
    request.getBuildProperties().getMaven().forEach((k, v) -> maven.put(k, v.get()));

    // Add various versions
    model.put("dependencyManagementPluginVersion",
            metadata.getConfiguration().getEnv().getGradle().getDependencyManagementPluginVersion());
    model.put("kotlinVersion", metadata.getConfiguration().getEnv().getKotlin().getVersion());
    if ("kotlin".equals(request.getLanguage())) {
        model.put("kotlin", true);
    }
    if ("groovy".equals(request.getLanguage())) {
        model.put("groovy", true);
    }

    model.put("isRelease", request.getBootVersion().contains("RELEASE"));
    // @SpringBootApplication available as from 1.2.0.RC1
    model.put("useSpringBootApplication",
            VERSION_1_2_0_RC1.compareTo(Version.safeParse(request.getBootVersion())) <= 0);

    // Gradle plugin has changed as from 1.3.0
    model.put("bootOneThreeAvailable",
            VERSION_1_3_0_M1.compareTo(Version.safeParse(request.getBootVersion())) <= 0);

    // Gradle plugin has changed again as from 1.4.2
    model.put("springBootPluginName",
            (VERSION_1_4_2_M1.compareTo(Version.safeParse(request.getBootVersion())) <= 0
                    ? "org.springframework.boot"
                    : "spring-boot"));

    // New testing stuff
    model.put("newTestInfrastructure", isNewTestInfrastructureAvailable(request));

    // New Servlet Initializer location
    model.put("newServletInitializer", isNewServletInitializerAvailable(request));

    // Java versions
    model.put("isJava6", isJavaVersion(request, "1.6"));
    model.put("isJava7", isJavaVersion(request, "1.7"));
    model.put("isJava8", isJavaVersion(request, "1.8"));

    // Append the project request to the model
    BeanWrapperImpl bean = new BeanWrapperImpl(request);
    for (PropertyDescriptor descriptor : bean.getPropertyDescriptors()) {
        if (bean.isReadableProperty(descriptor.getName())) {
            model.put(descriptor.getName(), bean.getPropertyValue(descriptor.getName()));
        }
    }
    if (!request.getBoms().isEmpty()) {
        model.put("hasBoms", true);
    }

    return model;
}

From source file:org.gvnix.web.datatables.util.impl.DatatablesUtilsBeanImpl.java

/**
 * {@inheritDoc}//from  w  w  w .j  a  v a2s .  c  o  m
 */
@Override
public <T> DataSet<Map<String, String>> populateDataSet(List<T> entities, String pkFieldName, long totalRecords,
        long totalDisplayRecords, List<ColumnDef> columns, Map<String, Object> datePatterns) {

    // Check arguments aren't null
    Assert.notNull(pkFieldName);
    Assert.notNull(columns);
    Assert.notNull(conversionService);

    // Map of data rows
    List<Map<String, String>> rows = new ArrayList<Map<String, String>>(entities.size());

    if (CollectionUtils.isEmpty(entities)) {
        return new DataSet<Map<String, String>>(rows, 0l, 0l);
    }

    // If null, create empty Map to avoid control code overload
    if (CollectionUtils.isEmpty(datePatterns)) {
        datePatterns = new HashMap<String, Object>();
    }
    Map<String, SimpleDateFormat> dateFormatters = new HashMap<String, SimpleDateFormat>(datePatterns.size());

    // Prepare required fields
    Set<String> fields = new HashSet<String>();
    fields.add(pkFieldName);

    // Add fields from request
    for (ColumnDef colum : columns) {
        fields.add(colum.getName());
    }

    BeanWrapperImpl entityBean = null;
    String valueStr = null;
    // Populate each row, note a row is a Map containing
    // fieldName = fieldValue
    for (T entity : entities) {
        Map<String, String> row = new HashMap<String, String>(fields.size());
        if (entityBean == null) {
            entityBean = new BeanWrapperImpl(entity);
        } else {
            entityBean.setWrappedInstance(entity);
        }
        for (String fieldName : fields) {

            String unescapedFieldName = unescapeDot(fieldName);

            // check if property exists (trace it else)
            if (!entityBean.isReadableProperty(unescapedFieldName)) {
                if (LOGGER.isTraceEnabled()) {
                    LOGGER.trace("Property [{}] not fond in bean {} [{}]", unescapedFieldName,
                            entity.getClass().getSimpleName(), entity);
                }
                row.put(fieldName, "");
                continue;
            }

            // Convert field value to string
            valueStr = convertFieldValueToString(datePatterns, dateFormatters, entityBean, entity, fieldName,
                    unescapedFieldName);
            row.put(fieldName, valueStr);

            // Set PK value as DT_RowId
            // Note when entity has composite PK Roo generates the need
            // convert method and adds it to ConversionService, so
            // when processed field is the PK the valueStr is the
            // composite PK instance marshalled to JSON notation and
            // Base64 encoded
            if (pkFieldName.equalsIgnoreCase(fieldName)) {
                row.put("DT_RowId", valueStr);
            }
        }
        rows.add(row);
    }
    DataSet<Map<String, String>> dataSet = new DataSet<Map<String, String>>(rows, totalRecords,
            totalDisplayRecords);
    return dataSet;
}

From source file:org.springjutsu.validation.ValidationManager.java

/**
 * Responsible for discovering the path-described model which
 * is to be validated by the current rule. This path may contain
 * EL, and if it does, we delegate to @link(#resolveEL(String, Object))
 * to resolve that EL./*from ww w  . j av  a 2 s.c o m*/
 * @param model Object to be validated
 * @param expression The string path expression for the model.
 * @return the Object to validate.
 */
protected Object getContextModel(Object model, String expression) {
    Object result = null;
    if (expression == null || expression.isEmpty()) {
        return model;
    }
    if (hasEL(expression)) {
        result = resolveSPEL(expression, model);
    } else {
        BeanWrapperImpl beanWrapper = new BeanWrapperImpl(model);
        if (model != null && beanWrapper.isReadableProperty(expression)) {
            result = beanWrapper.getPropertyValue(expression);
        }
    }
    return result;
}