/** * Converts a non-null bag of {@link JavaType}s into a {@link List} of * equivalent {@link AnnotatedJavaType}s. Note that each returned * {@link AnnotatedJavaType} will have no annotation metadata, as the input * {@link JavaType}s cannot store any such metadata. * * @param javaTypes to convert (can be <code>null</code> for none) * @return the equivalent {@link AnnotatedJavaType}s (never returns null) */ public static List<AnnotatedJavaType> convertFromJavaTypes( final Iterable<? extends JavaType> javaTypes) { final List<AnnotatedJavaType> result = new ArrayList<AnnotatedJavaType>(); if (javaTypes != null) { for (final JavaType javaType : javaTypes) { result.add(convertFromJavaType(javaType)); } } return result; }
/** * Method that generates count methods for custom finders. * * @param formBean the object containing the properties to search to * @param javaSymbolName the finder name * @return */ private MethodMetadata getCustomCount(JavaType formBean, JavaSymbolName finderName) { // Define method parameter types and parameter names List<AnnotatedJavaType> parameterTypes = new ArrayList<AnnotatedJavaType>(); parameterTypes.add(AnnotatedJavaType.convertFromJavaType(formBean)); List<JavaSymbolName> parameterNames = new ArrayList<JavaSymbolName>(); parameterNames.add(new JavaSymbolName("formBean")); // Create count method name String countName = finderName.getSymbolName(); if (StringUtils.startsWith(countName, "find")) { countName = StringUtils.removeStart(countName, "find"); } else if (StringUtils.startsWith(countName, "query")) { countName = StringUtils.removeStart(countName, "query"); } else if (StringUtils.startsWith(countName, "read")) { countName = StringUtils.removeStart(countName, "read"); } countName = "count".concat(countName); JavaSymbolName countMethodName = new JavaSymbolName(countName); // Use the MethodMetadataBuilder for easy creation of MethodMetadata MethodMetadataBuilder methodBuilder = new MethodMetadataBuilder(getId(), Modifier.PUBLIC + Modifier.ABSTRACT, countMethodName, JavaType.LONG_PRIMITIVE, parameterTypes, parameterNames, null); return methodBuilder.build(); // Build and return a MethodMetadata }
public void addParameter(final String parameterName, final JavaType parameterType) { addParameterName(new JavaSymbolName(parameterName)); addParameterType(AnnotatedJavaType.convertFromJavaType(parameterType)); }
/** * Method that generates finder methods whose return types are projections. * * @param finderReturnType * @param finderName * @param parameterType * * @return */ private MethodMetadata getCustomFinder(JavaType finderReturnType, JavaSymbolName finderName, JavaType parameterType) { // Define method parameter types and parameter names List<AnnotatedJavaType> parameterTypes = new ArrayList<AnnotatedJavaType>(); parameterTypes.add(AnnotatedJavaType.convertFromJavaType(parameterType)); parameterTypes.add(GLOBAL_SEARCH_PARAMETER); parameterTypes.add(PAGEABLE_PARAMETER); List<JavaSymbolName> parameterNames = new ArrayList<JavaSymbolName>(); parameterNames.add(new JavaSymbolName("formBean")); parameterNames.add(GOBAL_SEARCH_PARAMETER_NAME); parameterNames.add(PAGEABLE_PARAMETER_NAME); // Return type JavaType returnType = new JavaType(SpringJavaType.PAGE.getFullyQualifiedTypeName(), 0, DataType.TYPE, null, Arrays.asList(finderReturnType)); // Use the MethodMetadataBuilder for easy creation of MethodMetadata MethodMetadataBuilder methodBuilder = new MethodMetadataBuilder(getId(), Modifier.PUBLIC + Modifier.ABSTRACT, finderName, returnType, parameterTypes, parameterNames, null); return methodBuilder.build(); // Build and return a MethodMetadata }
/** * Method that generates finder method on current interface * * @param finderMethod * @return */ private MethodMetadataBuilder getFinderMethod(FinderMethod finderMethod) { // Define method parameter types and parameter names List<AnnotatedJavaType> parameterTypes = new ArrayList<AnnotatedJavaType>(); List<JavaSymbolName> parameterNames = new ArrayList<JavaSymbolName>(); for (FinderParameter param : finderMethod.getParameters()) { parameterTypes.add(AnnotatedJavaType.convertFromJavaType(param.getType())); parameterNames.add(param.getName()); } // Add additional Pageable method parameterTypes.add(AnnotatedJavaType.convertFromJavaType(SpringJavaType.PAGEABLE)); parameterNames.add(new JavaSymbolName("pageable")); // Use the MethodMetadataBuilder for easy creation of MethodMetadata MethodMetadataBuilder methodBuilder = new MethodMetadataBuilder(getId(), Modifier.PUBLIC + Modifier.ABSTRACT, finderMethod.getMethodName(), finderMethod.getReturnType(), parameterTypes, parameterNames, null); return methodBuilder; // Build and return a MethodMetadata // instance }
parameterTypes.add(AnnotatedJavaType.convertFromJavaType(JavaType.wrapperOf(JavaType.LIST, identifierType))); parameterNames.add(new JavaSymbolName("ids"));
parameterTypes.add(AnnotatedJavaType.convertFromJavaType(param.getType())); parameterNames.add(param.getName());
private MethodMetadata getFindOneMethod(JavaType entity, FieldMetadata identifierFieldMetadata) { // Define method parameter type and name List<AnnotatedJavaType> parameterTypes = new ArrayList<AnnotatedJavaType>(); List<JavaSymbolName> parameterNames = new ArrayList<JavaSymbolName>(); parameterTypes .add(AnnotatedJavaType.convertFromJavaType(identifierFieldMetadata.getFieldType())); parameterNames.add(identifierFieldMetadata.getFieldName()); MethodMetadata existingMethod = getGovernorMethod(FIND_ONE_METHOD_NAME, AnnotatedJavaType.convertFromAnnotatedJavaTypes(parameterTypes)); if (existingMethod != null) { return existingMethod; } // Use the MethodMetadataBuilder for easy creation of MethodMetadata return new MethodMetadataBuilder(getId(), Modifier.PUBLIC + Modifier.ABSTRACT, FIND_ONE_METHOD_NAME, entity, parameterTypes, parameterNames, null).build(); }
private MethodMetadata getSaveMethod(JavaType entity) { // Define method parameter type and name List<AnnotatedJavaType> parameterTypes = new ArrayList<AnnotatedJavaType>(); List<JavaSymbolName> parameterNames = new ArrayList<JavaSymbolName>(); parameterTypes.add(AnnotatedJavaType.convertFromJavaType(entity)); parameterNames.add(new JavaSymbolName(StringUtils.uncapitalize(entity.getSimpleTypeName()))); MethodMetadata existingMethod = getGovernorMethod(SAVE_METHOD_NAME, AnnotatedJavaType.convertFromAnnotatedJavaTypes(parameterTypes)); if (existingMethod != null) { return existingMethod; } // Use the MethodMetadataBuilder for easy creation of MethodMetadata return new MethodMetadataBuilder(getId(), Modifier.PUBLIC + Modifier.ABSTRACT, SAVE_METHOD_NAME, entity, parameterTypes, parameterNames, null).build(); }
private MethodMetadata getFindAllIteratorMethod(JavaType entity, FieldMetadata identifierFieldMetadata) { // Define method parameter type and name List<AnnotatedJavaType> parameterTypes = new ArrayList<AnnotatedJavaType>(); List<JavaSymbolName> parameterNames = new ArrayList<JavaSymbolName>(); parameterTypes.add(AnnotatedJavaType.convertFromJavaType(JavaType .iterableOf(identifierFieldMetadata.getFieldType()))); parameterNames.add(identifierFieldMetadata.getFieldName()); MethodMetadata existingMethod = getGovernorMethod(FIND_ALL_ITERATOR_METHOD_NAME, AnnotatedJavaType.convertFromAnnotatedJavaTypes(parameterTypes)); if (existingMethod != null) { return existingMethod; } // Use the MethodMetadataBuilder for easy creation of MethodMetadata return new MethodMetadataBuilder(getId(), Modifier.PUBLIC + Modifier.ABSTRACT, FIND_ALL_ITERATOR_METHOD_NAME, JavaType.listOf(entity), parameterTypes, parameterNames, null).build(); }
/** * Method that generates "save" method. * * @return MethodMetadataBuilder with public Entity save(Entity entity); * structure */ private MethodMetadata getSaveMethod() { // Define save method JavaSymbolName methodName = new JavaSymbolName("save"); // Define method parameter types List<AnnotatedJavaType> parameterTypes = new ArrayList<AnnotatedJavaType>(); parameterTypes.add(AnnotatedJavaType.convertFromJavaType(this.entity)); // Define method parameter names List<JavaSymbolName> parameterNames = new ArrayList<JavaSymbolName>(); parameterNames.add(new JavaSymbolName("entity")); MethodMetadata existingMethod = getGovernorMethod(methodName, AnnotatedJavaType.convertFromAnnotatedJavaTypes(parameterTypes)); if (existingMethod != null) { return existingMethod; } // Use the MethodMetadataBuilder for easy creation of MethodMetadata MethodMetadataBuilder methodBuilder = new MethodMetadataBuilder(getId(), Modifier.PUBLIC + Modifier.ABSTRACT, methodName, this.entity, parameterTypes, parameterNames, null); // Build a MethodMetadata instance return methodBuilder.build(); }
/** * Method that generates method "findOne". * * @return MethodMetadataBuilder with public Entity findOne(Long id); * structure */ private MethodMetadata getFindOneMethod() { // Define method name JavaSymbolName methodName = new JavaSymbolName("findOne"); // Define method parameter types List<AnnotatedJavaType> parameterTypes = new ArrayList<AnnotatedJavaType>(); parameterTypes.add(AnnotatedJavaType.convertFromJavaType(identifierType)); // Define method parameter names List<JavaSymbolName> parameterNames = new ArrayList<JavaSymbolName>(); parameterNames.add(entityMetadata.getCurrentIndentifierField().getFieldName()); MethodMetadata existingMethod = getGovernorMethod(methodName, AnnotatedJavaType.convertFromAnnotatedJavaTypes(parameterTypes)); if (existingMethod != null) { return existingMethod; } // Use the MethodMetadataBuilder for easy creation of MethodMetadata MethodMetadataBuilder methodBuilder = new MethodMetadataBuilder(getId(), Modifier.PUBLIC + Modifier.ABSTRACT, methodName, entity, parameterTypes, parameterNames, null); return methodBuilder.build(); // Build and return a MethodMetadata // instance }
/** * Generates the "findOneForUpdate" method to be able to control * concurrency in Entity updates. * * @return MethodMetadata with public Entity findOneForUpdate(T id); * structure */ private MethodMetadata getFindOneForUpdateMethod() { // Define method name JavaSymbolName methodName = new JavaSymbolName("findOneForUpdate"); // Define method parameter types List<AnnotatedJavaType> parameterTypes = new ArrayList<AnnotatedJavaType>(); parameterTypes.add(AnnotatedJavaType.convertFromJavaType(this.identifierType)); // Define method parameter names List<JavaSymbolName> parameterNames = new ArrayList<JavaSymbolName>(); parameterNames.add(this.entityMetadata.getCurrentIndentifierField().getFieldName()); MethodMetadata existingMethod = getGovernorMethod(methodName, AnnotatedJavaType.convertFromAnnotatedJavaTypes(parameterTypes)); if (existingMethod != null) { return existingMethod; } // Use the MethodMetadataBuilder for easy creation of MethodMetadata MethodMetadataBuilder methodBuilder = new MethodMetadataBuilder(getId(), Modifier.PUBLIC + Modifier.ABSTRACT, methodName, entity, parameterTypes, parameterNames, null); return methodBuilder.build(); // Build and return a MethodMetadata // instance }
parameterTypes.add(AnnotatedJavaType.convertFromJavaType(JavaType.iterableOf(identifierType)));
/** * This method provides populateFormats method that allows to configure date * time format for every entity * * @return */ private MethodMetadata getPopulateFormatsMethod() { // Define methodName final JavaSymbolName methodName = new JavaSymbolName("populateFormats"); List<AnnotatedJavaType> parameterTypes = new ArrayList<AnnotatedJavaType>(); parameterTypes.add(AnnotatedJavaType.convertFromJavaType(SpringJavaType.MODEL)); MethodMetadata existingMethod = getGovernorMethod(methodName, AnnotatedJavaType.convertFromAnnotatedJavaTypes(parameterTypes)); if (existingMethod != null) { return existingMethod; } final List<JavaSymbolName> parameterNames = new ArrayList<JavaSymbolName>(); parameterNames.add(MODEL_PARAM_NAME); // Adding annotations final List<AnnotationMetadataBuilder> annotations = new ArrayList<AnnotationMetadataBuilder>(); // Generate body InvocableMemberBodyBuilder bodyBuilder = new InvocableMemberBodyBuilder(); buildPopulateFormatBody(bodyBuilder, dateTimeFields); MethodMetadataBuilder methodBuilder = new MethodMetadataBuilder(getId(), Modifier.PUBLIC, methodName, JavaType.VOID_PRIMITIVE, parameterTypes, parameterNames, bodyBuilder); methodBuilder.setAnnotations(annotations); return methodBuilder.build(); }
/** * Method that generates method "findAll" with iterable parameter. * * @return MethodMetadataBuilder with public List <Entity> findAll(Iterable * <Long> ids) structure */ private MethodMetadata getFindAllIterableMethod() { // Define method name JavaSymbolName methodName = new JavaSymbolName("findAll"); // Define method parameter types List<AnnotatedJavaType> parameterTypes = new ArrayList<AnnotatedJavaType>(); parameterTypes.add(AnnotatedJavaType.convertFromJavaType(JavaType.iterableOf(identifierType))); // Define method parameter names List<JavaSymbolName> parameterNames = new ArrayList<JavaSymbolName>(); parameterNames.add(new JavaSymbolName("ids")); MethodMetadata existingMethod = getGovernorMethod(methodName, AnnotatedJavaType.convertFromAnnotatedJavaTypes(parameterTypes)); if (existingMethod != null) { return existingMethod; } JavaType listEntityJavaType = JavaType.listOf(entity); // Use the MethodMetadataBuilder for easy creation of MethodMetadata MethodMetadataBuilder methodBuilder = new MethodMetadataBuilder(getId(), Modifier.PUBLIC + Modifier.ABSTRACT, methodName, listEntityJavaType, parameterTypes, parameterNames, null); return methodBuilder.build(); // Build and return a MethodMetadata // instance }
/** * Method that generates "save" batch method. * * @return MethodMetadataBuilder with public List<Entity> save(Iterable * <Entity> entities); structure */ private MethodMetadata getSaveBatchMethod() { // Define method name JavaSymbolName methodName = new JavaSymbolName("save"); // Define method parameter types List<AnnotatedJavaType> parameterTypes = new ArrayList<AnnotatedJavaType>(); parameterTypes.add(AnnotatedJavaType.convertFromJavaType(JavaType.iterableOf(entity))); // Define method parameter names List<JavaSymbolName> parameterNames = new ArrayList<JavaSymbolName>(); parameterNames.add(new JavaSymbolName("entities")); JavaType listEntityJavaType = JavaType.listOf(entity); MethodMetadata existingMethod = getGovernorMethod(methodName, AnnotatedJavaType.convertFromAnnotatedJavaTypes(parameterTypes)); if (existingMethod != null) { return existingMethod; } // Use the MethodMetadataBuilder for easy creation of MethodMetadata MethodMetadataBuilder methodBuilder = new MethodMetadataBuilder(getId(), Modifier.PUBLIC + Modifier.ABSTRACT, methodName, listEntityJavaType, parameterTypes, parameterNames, null); // Build a MethodMetadata instance return methodBuilder.build(); }
/** * Method that generates "delete" method. * * @return MethodMetadataBuilder with public void delete(Entity entity); structure */ private MethodMetadata getDeleteMethod() { // Define method name JavaSymbolName methodName = new JavaSymbolName("delete"); // Define method parameter types List<AnnotatedJavaType> parameterTypes = new ArrayList<AnnotatedJavaType>(); parameterTypes.add(AnnotatedJavaType.convertFromJavaType(this.entity)); // Define method parameter names List<JavaSymbolName> parameterNames = new ArrayList<JavaSymbolName>(); parameterNames .add(new JavaSymbolName(StringUtils.uncapitalize(this.entity.getSimpleTypeName()))); MethodMetadata existingMethod = getGovernorMethod(methodName, AnnotatedJavaType.convertFromAnnotatedJavaTypes(parameterTypes)); if (existingMethod != null) { return existingMethod; } // Use the MethodMetadataBuilder for easy creation of MethodMetadata MethodMetadataBuilder methodBuilder = new MethodMetadataBuilder(getId(), Modifier.PUBLIC + Modifier.ABSTRACT, methodName, JavaType.VOID_PRIMITIVE, parameterTypes, parameterNames, null); // Build a MethodMetadata instance return methodBuilder.build(); }
parameterTypes.add(AnnotatedJavaType.convertFromJavaType(SpringJavaType.MODEL));
List<JavaSymbolName> parameterNames = new ArrayList<JavaSymbolName>(); final JavaType paramType = field.getFieldType().getBaseType(); parameterTypes.add(AnnotatedJavaType.convertFromJavaType(paramType)); parameterNames.add(new JavaSymbolName(StringUtils.uncapitalize(field.getFieldName() .getSymbolName())));