new JavaSymbolName(addToMethod.getMethodName().getSymbolName() + "Batch"); parameterTypes.add(new AnnotatedJavaType(addToMethod.getParameterTypes().get(0).getJavaType(), ANN_MODEL_ATTRIBUTE)); parameterTypes.add(new AnnotatedJavaType(addToMethod.getParameterTypes().get(1).getJavaType(), ANN_REQUEST_BODY)); postMappingAnnotation.addStringAttribute("name", methodName.getSymbolName()); postMappingAnnotation.addStringAttribute("value", "/batch"); annotations.add(postMappingAnnotation); parameterNames.addAll(addToMethod.getParameterNames()); InvocableMemberBodyBuilder bodyBuilder = new InvocableMemberBodyBuilder(); bodyBuilder.appendFormalLine("%s().%s(%s,%s);", getAccessorMethod(detailsServiceField) .getMethodName(), addToMethod.getMethodName(), addToMethod.getParameterNames().get(0), addToMethod.getParameterNames().get(1)); bodyBuilder.appendFormalLine("return %s.ok().build();", getNameOfJavaType(RESPONSE_ENTITY)); new MethodMetadataBuilder(getId(), Modifier.PUBLIC, methodName, JavaType.wrapperWilcard(RESPONSE_ENTITY), parameterTypes, parameterNames, bodyBuilder); methodBuilder.setAnnotations(annotations); return methodBuilder.build();
JavaSymbolName methodName = method.getMethodName(); List<AnnotatedJavaType> parameterTypes = method.getParameterTypes(); List<JavaSymbolName> parameterNames = method.getParameterNames(); AnnotatedJavaType.convertFromAnnotatedJavaTypes(parameterTypes)); if (existingMethod != null) { return existingMethod; InvocableMemberBodyBuilder bodyBuilder = new InvocableMemberBodyBuilder(); String entity = this.entity.getSimpleTypeName(); String entityVariable = StringUtils.uncapitalize(entity); JavaType finderParamType = parameterTypes.get(0).getJavaType(); String finderParamName = parameterNames.get(0).getSymbolName(); bodyBuilder.newLine(); bodyBuilder.appendFormalLine(String.format("%1$s %2$s = %1$s.%2$s;", getNameOfJavaType(entityQtype), entityVariable)); bodyBuilder.newLine(); new MethodMetadataBuilder(getId(), Modifier.PUBLIC, methodName, method.getReturnType(), parameterTypes, parameterNames, bodyBuilder); return methodBuilder.build();
/** * This method generates new method instance using an existing * methodMetadata * * @param declaredByMetadataId * @param method * * @return */ private MethodMetadata getNewMethod(String declaredByMetadataId, MethodMetadata method) { // Create bodyBuilder InvocableMemberBodyBuilder bodyBuilder = new InvocableMemberBodyBuilder(); bodyBuilder.appendFormalLine(method.getBody()); // Use the MethodMetadataBuilder for easy creation of MethodMetadata // based on existing method MethodMetadataBuilder methodBuilder = new MethodMetadataBuilder(declaredByMetadataId, method.getModifier(), method.getMethodName(), method.getReturnType(), method.getParameterTypes(), method.getParameterNames(), bodyBuilder); methodBuilder.setAnnotations(method.getAnnotations()); // ROO-3834: Including default comment structure during push-in methodBuilder.setCommentStructure(method.getCommentStructure()); return methodBuilder.build(); }
public MethodMetadataBuilder(final MethodMetadata existing) { super(existing); init(existing.getMethodName(), existing.getReturnType()); }
private JavaSymbolName getParameterNameFor(MethodMetadata method, JavaType type) { AnnotatedJavaType parameter; for (int i = 0; i < method.getParameterTypes().size(); i++) { parameter = method.getParameterTypes().get(i); if (parameter.getJavaType().equals(type)) { return method.getParameterNames().get(i); } } return null; }
/** * Indicates if the presented method compiles with the JavaBean conventions * around mutator methods (public, "set", 1 arg etc). * * @param method to evaluate (required) * @return true if the presented method is a mutator, otherwise false */ public static boolean isMutatorMethod(final MethodMetadata method) { Validate.notNull(method, "Method is required"); return method.getMethodName().getSymbolName().startsWith("set") && method.getParameterTypes().size() == 1 && Modifier.isPublic(method.getModifier()); }
parameterTypes.add(new AnnotatedJavaType(this.entity, ANN_METADATA_MODEL_ATTRIBUTE)); AnnotatedJavaType.convertFromAnnotatedJavaTypes(parameterTypes)); if (existingMethod != null) { return existingMethod; parameterNames.add(new JavaSymbolName(entityItemName)); deleteMapping.addStringAttribute("name", methodName.getSymbolName()); annotations.add(RESPONSE_BODY_ANNOTATION); annotations.add(deleteMapping); this.mvcMethodNames.put(methodName.getSymbolName(), methodName.getSymbolName()); InvocableMemberBodyBuilder bodyBuilder = new InvocableMemberBodyBuilder(); bodyBuilder.appendFormalLine("%s().%s(%s);", getAccessorMethod(controllerMetadata.getServiceField()).getMethodName(), serviceMetadata .getCurrentDeleteMethod().getMethodName(), entityItemName); bodyBuilder.appendFormalLine("return %s.ok().build();", getNameOfJavaType(RESPONSE_ENTITY)); new MethodMetadataBuilder(getId(), Modifier.PUBLIC, methodName, JavaType.wrapperWilcard(RESPONSE_ENTITY), parameterTypes, parameterNames, bodyBuilder); methodBuilder.setAnnotations(annotations); return methodBuilder.build();
if (method.getMethodName().toString() .compareTo(methodName.toString()) != 0) { InvocableMemberBodyBuilder bodyBuilder = new InvocableMemberBodyBuilder(); bodyBuilder.appendFormalLine(method.getBody()); MethodMetadataBuilder methodMetadataBuilder = new MethodMetadataBuilder( targetId, method.getModifier(), method.getMethodName(), method.getReturnType(), method.getParameterTypes(), method.getParameterNames(), bodyBuilder); for (AnnotationMetadata annotationMetadata : method .getAnnotations()) { methodMetadataBuilder.addAnnotation(annotationMetadata); for (JavaType javaType : method.getThrowsTypes()) { methodMetadataBuilder.addThrowsType(javaType);
new JavaSymbolName("list" + StringUtils.capitalize(detailsInfo.fieldName)); parameterTypes.add(new AnnotatedJavaType( findAllMethod.getParameterTypes().get(0).getJavaType(), ANN_MODEL_ATTRIBUTE)); parameterTypes.add(new AnnotatedJavaType(SpringletsJavaType.SPRINGLETS_GLOBAL_SEARCH)); parameterTypes.add(new AnnotatedJavaType(SpringJavaType.PAGEABLE)); final JavaSymbolName parentParamName = findAllMethod.getParameterNames().get(0); parameterNames.add(parentParamName); parameterNames.add(GLOBAL_SEARCH_NAME); getMappingAnnotation.addStringAttribute("name", methodName.getSymbolName()); annotations.add(getMappingAnnotation); JavaType serviceReturnType = findAllMethod.getReturnType(); JavaType returnType = JavaType.wrapperOf(RESPONSE_ENTITY, serviceReturnType); InvocableMemberBodyBuilder bodyBuilder = new InvocableMemberBodyBuilder(); bodyBuilder.newLine(); bodyBuilder.appendFormalLine("%s %s = %s().%s(%s, %s, %s);", getNameOfJavaType(serviceReturnType), itemNames, getAccessorMethod(detailsServiceField) .getMethodName(), findAllMethod.getMethodName(), parentParamName, GLOBAL_SEARCH_NAME, PAGEABLE_PARAM_NAME); return methodBuilder.build();
new JavaSymbolName("get" + StringUtils.capitalize(pathVariable)); serviceMetadata.getCurrentFindOneMethod().getParameterTypes().get(0).getJavaType(); final JavaSymbolName idName = serviceMetadata.getCurrentFindOneMethod().getParameterNames().get(0); final JavaType entityType = serviceMetadata.getCurrentFindOneMethod().getReturnType(); pathVariableAnnotation.addStringAttribute("value", StringUtils.uncapitalize(pathVariable)); parameterTypes.add(new AnnotatedJavaType(idType, pathVariableAnnotation.build())); AnnotatedJavaType.convertFromAnnotatedJavaTypes(parameterTypes)); if (existingMethod != null) { return existingMethod; InvocableMemberBodyBuilder bodyBuilder = new InvocableMemberBodyBuilder(); bodyBuilder.appendFormalLine("%s %s = %s.%s(%s);", getNameOfJavaType(entityType), pathVariable, serviceField.getFieldName(), serviceMetadata.getCurrentFindOneMethod().getMethodName(), idName); new MethodMetadataBuilder(getId(), Modifier.PUBLIC, methodName, entityType, parameterTypes, parameterNames, bodyBuilder); methodBuilder.addAnnotation(ANN_MODEL_ATTRIBUTE); return methodBuilder.build();
new JavaSymbolName("getRandom" + this.entity.getSimpleTypeName()); Validate.isTrue(userMethod.getReturnType().equals(this.entity), "Method '%s' on '%s' must return '%s'", methodName, this.destination, this.entity.getSimpleTypeName()); this.randomPersistentEntityMethod = userMethod; return userMethod; final InvocableMemberBodyBuilder bodyBuilder = new InvocableMemberBodyBuilder(); bodyBuilder.appendFormalLine("init();"); bodyBuilder.appendFormalLine("return %1$s().get(%2$s().nextInt(%1$s().size()));", getAccessorMethod(getDataField().build()).getMethodName(), getAccessorMethod(getRndField().build()).getMethodName()); new MethodMetadataBuilder(getId(), Modifier.PUBLIC, methodName, this.entity, bodyBuilder); this.entity.getSimpleTypeName()), null); comment.addComment(javadocComment, CommentLocation.BEGINNING); methodBuilder.setCommentStructure(comment); this.randomPersistentEntityMethod = methodBuilder.build(); return this.randomPersistentEntityMethod;
InvocableMemberBodyBuilder bodyBuilder = new InvocableMemberBodyBuilder(); bodyBuilder.appendFormalLine("%s endpoint = new EndpointImpl(%s(), new %s(%s()));", getNameOfJavaType(new JavaType("org.apache.cxf.jaxws.EndpointImpl")), getAccessorMethod(getBusField()).getMethodName(), getNameOfJavaType(endpoint), getAccessorMethod(getServiceField(getServiceFromEndpoint(endpoint))).getMethodName()); bodyBuilder.appendFormalLine("endpoint.setFeatures(%s.asList(new %s(), new %s()));", getNameOfJavaType(JavaType.ARRAYS), getNameOfJavaType(new JavaType( "io.tracee.binding.cxf.TraceeCxfFeature")), getNameOfJavaType(new JavaType( "org.apache.cxf.feature.LoggingFeature"))); new MethodMetadataBuilder(getId(), Modifier.PUBLIC, new JavaSymbolName( StringUtils.uncapitalize(endpoint.getSimpleTypeName())), JavaType.ENDPOINT, bodyBuilder); endpointMethod.addAnnotation(new AnnotationMetadataBuilder(SpringJavaType.BEAN)); endpointMethods.put(endpoint, endpointMethod.build()); return endpointMethod.build();
new JavaSymbolName(JpaEntityFactoryMetadata.SPECIFIC_METHOD_PREFIX + this.entity.getSimpleTypeName()); final JavaType parameterType = JavaType.INT_PRIMITIVE; final List<JavaSymbolName> parameterNames = Arrays.asList(INDEX_SYMBOL); Validate.isTrue(userMethod.getReturnType().equals(this.entity), "Method '%s on '%s' must return '%s'", methodName, this.destination, this.entity.getSimpleTypeName()); this.specificEntityMethod = userMethod; return userMethod; final InvocableMemberBodyBuilder bodyBuilder = new InvocableMemberBodyBuilder(); bodyBuilder.appendFormalLine("init();"); bodyBuilder.appendFormalLine("if (" + INDEX_VAR + " < 0) {"); + getAccessorMethod(getDataField().build()).getMethodName() + "().size() - 1)) {"); + getAccessorMethod(getDataField().build()).getMethodName() + "().size() - 1;"); .getMethodName(), INDEX_VAR); new MethodMetadataBuilder(getId(), Modifier.PUBLIC, methodName, this.entity, AnnotatedJavaType.convertFromJavaTypes(parameterType), parameterNames, bodyBuilder); methodBuilder.setCommentStructure(comment); this.specificEntityMethod = methodBuilder.build(); return this.specificEntityMethod;
final JavaType parentEntity = info.entityType; final JavaType entity = info.childType; final String entityItemName = StringUtils.uncapitalize(entity.getSimpleTypeName()); parameterTypes.add(new AnnotatedJavaType(parentEntity, ANN_METADATA_MODEL_ATTRIBUTE)); parameterTypes.add(new AnnotatedJavaType(entity, ANN_METADATA_MODEL_ATTRIBUTE)); parameterTypes.add(MODEL_PARAM); AnnotatedJavaType.convertFromAnnotatedJavaTypes(parameterTypes)); if (existingMethod != null) { return existingMethod; getMapping.addStringAttribute("name", methodName.getSymbolName()); annotations.add(getMapping); this.mvcMethodNames.put(methodName.getSymbolName(), methodName.getSymbolName()); final InvocableMemberBodyBuilder bodyBuilder = new InvocableMemberBodyBuilder(); bodyBuilder.appendFormalLine("%s(model);", populateFormMethod.getMethodName()); bodyBuilder.newLine(); new MethodMetadataBuilder(getId(), Modifier.PUBLIC, methodName, SpringJavaType.MODEL_AND_VIEW, parameterTypes, parameterNames, bodyBuilder); methodBuilder.setAnnotations(annotations); return methodBuilder.build();
/** * Method that generates custom count method. * * @return MethodMetadata */ private MethodMetadata getCustomCountMethod(MethodMetadata customCountMethod) { // Use the MethodMetadataBuilder for easy creation of MethodMetadata MethodMetadataBuilder methodBuilder = new MethodMetadataBuilder(getId(), Modifier.PUBLIC + Modifier.ABSTRACT, customCountMethod.getMethodName(), customCountMethod.getReturnType(), customCountMethod.getParameterTypes(), customCountMethod.getParameterNames(), null); return methodBuilder.build(); // Build and return a MethodMetadata // instance }
/** * Build "findOneForUpdate" method body which delegates on repository * * @param methodToBeImplemented * @return */ private InvocableMemberBodyBuilder buildFindOneForUpdateBody(MethodMetadata methodToBeImplemented) { // Generate body InvocableMemberBodyBuilder bodyBuilder = new InvocableMemberBodyBuilder(); final JavaSymbolName param0 = methodToBeImplemented.getParameterNames().get(0); // return entityRepository.findOneDetached(id); bodyBuilder.appendFormalLine("%s %s().%s(%s);", methodToBeImplemented.getReturnType().equals(JavaType.VOID_PRIMITIVE) ? "" : "return", getAccessorMethod(repositoryFieldMetadata).getMethodName(), FIND_ONE_DETACHED.getSymbolName(), param0); return bodyBuilder; }
new JavaSymbolName("init" + entity.getSimpleTypeName() + "Binder"); InvocableMemberBodyBuilder body = new InvocableMemberBodyBuilder(); body.appendFormalLine("binder.setDisallowedFields(\"%s\");", entityIdentifier); body.appendFormalLine("binder.setDisallowedFields(\"%s.%s\");", item.getKey().fieldName, item .getValue().getCurrentIndentifierField().getFieldName()); body.appendFormalLine("// Register validators"); body.appendFormalLine("%s validator = new GenericValidator(%s.class, %s());", SpringletsJavaType.SPRINGLETS_GENERIC_VALIDATOR.getNameIncludingTypeParameters(false, builder.getImportRegistrationResolver()), entity.getBaseType() .getNameIncludingTypeParameters(false, builder.getImportRegistrationResolver()), getAccessorMethod(controllerMetadata.getServiceField()).getMethodName()); body.appendFormalLine("binder.addValidators(validator);"); new MethodMetadataBuilder(getId(), Modifier.PUBLIC, methodName, JavaType.VOID_PRIMITIVE, parameterTypes, parameterNames, body); annotations.add(getInitBinderAnnotation); methodBuilder.setAnnotations(annotations); return methodBuilder.build();
for (AnnotatedJavaType type : seiMethod.getParameterTypes()) { parameters.add(type.getJavaType()); new MethodMetadataBuilder(getId(), Modifier.PUBLIC, seiMethod.getMethodName(), seiMethod.getReturnType(), AnnotatedJavaType.convertFromJavaTypes(parameters), seiMethod.getParameterNames(), null); InvocableMemberBodyBuilder bodyBuilder = new InvocableMemberBodyBuilder(); for (JavaSymbolName param : seiMethod.getParameterNames()) { parametersList = parametersList.concat(param.getSymbolName()).concat(", "); bodyBuilder.appendFormalLine("%s%s().%s(%s);", seiMethod.getReturnType() != JavaType.VOID_PRIMITIVE ? "return " : "", getAccessorMethod(getServiceField()).getMethodName(), serviceMethod.getMethodName() .getSymbolName(), parametersList); endpointMethod.setBodyBuilder(bodyBuilder); endpointMethods.add(endpointMethod.build());
if (method.getReturnType().isPrimitive()) { returnType = JavaParserUtils.getType(method.getReturnType()); if (method.getReturnType().isArray()) { final ReferenceType rt = new ReferenceType(); rt.setArrayCount(method.getReturnType().getArray()); rt.setType(returnType); returnType = rt; final NameExpr importedType = JavaParserUtils.importTypeIfRequired(compilationUnitServices.getEnclosingTypeName(), compilationUnitServices.getImports(), method.getReturnType()); final ClassOrInterfaceType cit = JavaParserUtils.getClassOrInterfaceType(importedType); if (method.getReturnType().getParameters().size() > 0) { final List<Type> typeArgs = new ArrayList<Type>(); cit.setTypeArgs(typeArgs); for (final JavaType parameter : method.getReturnType().getParameters()) { typeArgs.add(JavaParserUtils.importParametersForType( compilationUnitServices.getEnclosingTypeName(), compilationUnitServices.getImports(), if (method.getReturnType().isArray()) { final ReferenceType rt = new ReferenceType(); rt.setArrayCount(method.getReturnType().getArray()); rt.setType(cit); returnType = rt; d.setModifiers(JavaParserUtils.getJavaParserModifier(method.getModifier())); d.setName(method.getMethodName().getSymbolName());
private MethodMetadata getRemoveFromRelationMethod(RelationInfo relationInfo) { final MethodMetadata entityRemoveMethod = relationInfo.removeMethod; JavaSymbolName methodName = entityRemoveMethod.getMethodName(); parameterTypes.add(AnnotatedJavaType.convertFromJavaType(entity)); parameterNames.add(new JavaSymbolName(StringUtils.uncapitalize(entity.getSimpleTypeName()))); parameterTypes.add(AnnotatedJavaType.convertFromJavaType(JavaType .iterableOf(childEntityMetadata.getCurrentIndentifierField().getFieldType()))); parameterNames.add(entityRemoveMethod.getParameterNames().get(0)); AnnotatedJavaType.convertFromAnnotatedJavaTypes(parameterTypes)); if (existingMethod != null) { return existingMethod; new MethodMetadataBuilder(getId(), Modifier.PUBLIC + Modifier.ABSTRACT, methodName, entity, parameterTypes, parameterNames, null); return methodBuilder.build(); // Build and return a MethodMetadata