/** @return a test for the find (by ID) method, if available and requested (may return null) */ private MethodMetadataBuilder getFindMethodTest( final MemberTypeAdditions findMethod, final MethodMetadata identifierAccessorMethod) { if (!annotationValues.isFind() || findMethod == null || identifierAccessorMethod == null) { // User does not want this method return null; } // Prepare method signature JavaSymbolName methodName = new JavaSymbolName("test" + StringUtils.capitalize(findMethod.getMethodName())); if (governorHasMethod(methodName)) { return null; } builder.getImportRegistrationResolver().addImport(identifierAccessorMethod.getReturnType()); List<AnnotationMetadataBuilder> annotations = new ArrayList<AnnotationMetadataBuilder>(); annotations.add(new AnnotationMetadataBuilder(TEST)); final String entityName = annotationValues.getEntity().getSimpleTypeName(); InvocableMemberBodyBuilder bodyBuilder = new InvocableMemberBodyBuilder(); bodyBuilder.appendFormalLine( entityName + " obj = dod." + dataOnDemandMetadata.getRandomPersistentEntityMethod().getMethodName().getSymbolName() + "();"); bodyBuilder.appendFormalLine( "Assert.assertNotNull(\"Data on demand for '" + entityName + "' failed to initialize correctly\", obj);"); bodyBuilder.appendFormalLine( identifierAccessorMethod.getReturnType().getSimpleTypeName() + " id = obj." + identifierAccessorMethod.getMethodName().getSymbolName() + "();"); bodyBuilder.appendFormalLine( "Assert.assertNotNull(\"Data on demand for '" + entityName + "' failed to provide an identifier\", id);"); bodyBuilder.appendFormalLine("obj = " + findMethod.getMethodCall() + ";"); bodyBuilder.appendFormalLine( "Assert.assertNotNull(\"Find method for '" + entityName + "' illegally returned null for id '\" + id + \"'\", obj);"); bodyBuilder.appendFormalLine( "Assert.assertEquals(\"Find method for '" + entityName + "' returned the incorrect identifier\", id, obj." + identifierAccessorMethod.getMethodName().getSymbolName() + "());"); findMethod.copyAdditionsTo(builder, governorTypeDetails); MethodMetadataBuilder methodBuilder = new MethodMetadataBuilder( getId(), Modifier.PUBLIC, methodName, JavaType.VOID_PRIMITIVE, bodyBuilder); methodBuilder.setAnnotations(annotations); return methodBuilder; }
/** @return the find all method (may return null) */ private MethodMetadata getFindAllMethod() { if ("".equals(crudAnnotationValues.getFindAllMethod())) { return null; } // Method definition to find or build final JavaSymbolName methodName = new JavaSymbolName(crudAnnotationValues.getFindAllMethod() + plural); final JavaType[] parameterTypes = {}; final List<JavaSymbolName> parameterNames = new ArrayList<JavaSymbolName>(); final JavaType returnType = new JavaType( LIST.getFullyQualifiedTypeName(), 0, DataType.TYPE, null, Arrays.asList(destination)); // Locate user-defined method final MethodMetadata userMethod = getGovernorMethod(methodName, parameterTypes); if (userMethod != null) { Assert.isTrue( userMethod.getReturnType().equals(returnType), "Method '" + methodName + "' on '" + destination + "' must return '" + returnType.getNameIncludingTypeParameters() + "'"); return userMethod; } // Create method final List<AnnotationMetadataBuilder> annotations = new ArrayList<AnnotationMetadataBuilder>(); if (isGaeEnabled) { addTransactionalAnnotation(annotations); } final InvocableMemberBodyBuilder bodyBuilder = new InvocableMemberBodyBuilder(); bodyBuilder.appendFormalLine( "return " + ENTITY_MANAGER_METHOD_NAME + "().createQuery(\"SELECT o FROM " + entityName + " o\", " + destination.getSimpleTypeName() + ".class).getResultList();"); final MethodMetadataBuilder methodBuilder = new MethodMetadataBuilder( getId(), Modifier.PUBLIC | Modifier.STATIC, methodName, returnType, AnnotatedJavaType.convertFromJavaTypes(parameterTypes), parameterNames, bodyBuilder); methodBuilder.setAnnotations(annotations); return methodBuilder.build(); }
private MethodMetadata getFromJsonArrayMethod() { // Compute the relevant method name JavaSymbolName methodName = getFromJsonArrayMethodName(); if (methodName == null) { return null; } final JavaType parameterType = JavaType.STRING; MethodMetadata result = getGovernorMethod(methodName, parameterType); if (result != null) { return result; } String list = new JavaType("java.util.List") .getNameIncludingTypeParameters(false, builder.getImportRegistrationResolver()); String arrayList = new JavaType("java.util.ArrayList") .getNameIncludingTypeParameters(false, builder.getImportRegistrationResolver()); String bean = destination.getSimpleTypeName(); InvocableMemberBodyBuilder bodyBuilder = new InvocableMemberBodyBuilder(); String deserializer = new JavaType("flexjson.JSONDeserializer") .getNameIncludingTypeParameters(false, builder.getImportRegistrationResolver()); bodyBuilder.appendFormalLine( "return new " + deserializer + "<" + list + "<" + bean + ">>().use(null, " + arrayList + ".class).use(\"values\", " + bean + ".class).deserialize(json);"); List<JavaSymbolName> parameterNames = Arrays.asList(new JavaSymbolName("json")); JavaType collection = new JavaType("java.util.Collection", 0, DataType.TYPE, null, Arrays.asList(destination)); MethodMetadataBuilder methodBuilder = new MethodMetadataBuilder( getId(), Modifier.PUBLIC | Modifier.STATIC, methodName, collection, AnnotatedJavaType.convertFromJavaTypes(parameterType), parameterNames, bodyBuilder); methodBuilder.putCustomData(CustomDataJsonTags.FROM_JSON_ARRAY_METHOD, null); return methodBuilder.build(); }
/** @return a test for the find entries method, if available and requested (may return null) */ private MethodMetadataBuilder getFindEntriesMethodTest( final MemberTypeAdditions countMethod, final MemberTypeAdditions findEntriesMethod) { if (!annotationValues.isFindEntries() || countMethod == null || findEntriesMethod == null) { // User does not want this method, or core dependencies are missing return null; } // Prepare method signature JavaSymbolName methodName = new JavaSymbolName("test" + StringUtils.capitalize(findEntriesMethod.getMethodName())); if (governorHasMethod(methodName)) { return null; } builder.getImportRegistrationResolver().addImport(LIST); List<AnnotationMetadataBuilder> annotations = new ArrayList<AnnotationMetadataBuilder>(); annotations.add(new AnnotationMetadataBuilder(TEST)); final String entityName = annotationValues.getEntity().getSimpleTypeName(); InvocableMemberBodyBuilder bodyBuilder = new InvocableMemberBodyBuilder(); bodyBuilder.appendFormalLine( "Assert.assertNotNull(\"Data on demand for '" + entityName + "' failed to initialize correctly\", dod." + dataOnDemandMetadata.getRandomPersistentEntityMethod().getMethodName().getSymbolName() + "());"); bodyBuilder.appendFormalLine("long count = " + countMethod.getMethodCall() + ";"); bodyBuilder.appendFormalLine("if (count > 20) count = 20;"); bodyBuilder.appendFormalLine("int firstResult = 0;"); bodyBuilder.appendFormalLine("int maxResults = (int) count;"); bodyBuilder.appendFormalLine( "List<" + entityName + "> result = " + findEntriesMethod.getMethodCall() + ";"); bodyBuilder.appendFormalLine( "Assert.assertNotNull(\"Find entries method for '" + entityName + "' illegally returned null\", result);"); bodyBuilder.appendFormalLine( "Assert.assertEquals(\"Find entries method for '" + entityName + "' returned an incorrect number of entries\", count, result.size());"); findEntriesMethod.copyAdditionsTo(builder, governorTypeDetails); countMethod.copyAdditionsTo(builder, governorTypeDetails); MethodMetadataBuilder methodBuilder = new MethodMetadataBuilder( getId(), Modifier.PUBLIC, methodName, JavaType.VOID_PRIMITIVE, bodyBuilder); methodBuilder.setAnnotations(annotations); return methodBuilder; }
/** @return a test for the count method, if available and requested (may return null) */ private MethodMetadataBuilder getCountMethodTest(final MemberTypeAdditions countMethod) { if (!annotationValues.isCount() || countMethod == null) { // User does not want this method return null; } // Prepare method signature JavaSymbolName methodName = new JavaSymbolName("test" + StringUtils.capitalize(countMethod.getMethodName())); if (governorHasMethod(methodName)) { return null; } List<AnnotationMetadataBuilder> annotations = new ArrayList<AnnotationMetadataBuilder>(); annotations.add(new AnnotationMetadataBuilder(TEST)); final String entityName = annotationValues.getEntity().getSimpleTypeName(); InvocableMemberBodyBuilder bodyBuilder = new InvocableMemberBodyBuilder(); bodyBuilder.appendFormalLine( "Assert.assertNotNull(\"Data on demand for '" + entityName + "' failed to initialize correctly\", dod." + dataOnDemandMetadata.getRandomPersistentEntityMethod().getMethodName().getSymbolName() + "());"); bodyBuilder.appendFormalLine("long count = " + countMethod.getMethodCall() + ";"); bodyBuilder.appendFormalLine( "Assert.assertTrue(\"Counter for '" + entityName + "' incorrectly reported there were no entries\", count > 0);"); countMethod.copyAdditionsTo(builder, governorTypeDetails); MethodMetadataBuilder methodBuilder = new MethodMetadataBuilder( getId(), Modifier.PUBLIC, methodName, JavaType.VOID_PRIMITIVE, bodyBuilder); methodBuilder.setAnnotations(annotations); return methodBuilder; }
private MethodMetadata getToJsonArrayMethod() { // Compute the relevant method name JavaSymbolName methodName = getToJsonArrayMethodName(); if (methodName == null) { return null; } final JavaType parameterType = new JavaType( Collection.class.getName(), 0, DataType.TYPE, null, Arrays.asList(destination)); // See if the type itself declared the method MethodMetadata result = getGovernorMethod(methodName, parameterType); if (result != null) { return result; } List<JavaSymbolName> parameterNames = Arrays.asList(new JavaSymbolName("collection")); InvocableMemberBodyBuilder bodyBuilder = new InvocableMemberBodyBuilder(); String serializer = new JavaType("flexjson.JSONSerializer") .getNameIncludingTypeParameters(false, builder.getImportRegistrationResolver()); String root = annotationValues.getRootName() != null && annotationValues.getRootName().length() > 0 ? ".rootName(\"" + annotationValues.getRootName() + "\")" : ""; bodyBuilder.appendFormalLine( "return new " + serializer + "()" + root + ".exclude(\"*.class\")" + (annotationValues.isDeepSerialize() ? ".deepSerialize(collection)" : ".serialize(collection)") + ";"); MethodMetadataBuilder methodBuilder = new MethodMetadataBuilder( getId(), Modifier.PUBLIC | Modifier.STATIC, methodName, new JavaType("java.lang.String"), AnnotatedJavaType.convertFromJavaTypes(parameterType), parameterNames, bodyBuilder); methodBuilder.putCustomData(CustomDataJsonTags.TO_JSON_ARRAY_METHOD, null); return methodBuilder.build(); }
/** * Finds (creating if necessary) the method that counts entities of this type * * @return the count method (never null) */ private MethodMetadata getCountMethod() { // Method definition to find or build final JavaSymbolName methodName = new JavaSymbolName(crudAnnotationValues.getCountMethod() + plural); final JavaType[] parameterTypes = {}; final List<JavaSymbolName> parameterNames = Collections.<JavaSymbolName>emptyList(); // Locate user-defined method final MethodMetadata userMethod = getGovernorMethod(methodName, parameterTypes); if (userMethod != null) { Assert.isTrue( userMethod.getReturnType().equals(COUNT_RETURN_TYPE), "Method '" + methodName + "' on '" + destination + "' must return '" + COUNT_RETURN_TYPE.getNameIncludingTypeParameters() + "'"); return userMethod; } // Create method final List<AnnotationMetadataBuilder> annotations = new ArrayList<AnnotationMetadataBuilder>(); if (isGaeEnabled) { addTransactionalAnnotation(annotations); } final InvocableMemberBodyBuilder bodyBuilder = new InvocableMemberBodyBuilder(); bodyBuilder.appendFormalLine( "return " + ENTITY_MANAGER_METHOD_NAME + "().createQuery(\"SELECT COUNT(o) FROM " + entityName + " o\", Long.class).getSingleResult();"); final MethodMetadataBuilder methodBuilder = new MethodMetadataBuilder( getId(), Modifier.PUBLIC | Modifier.STATIC, methodName, COUNT_RETURN_TYPE, AnnotatedJavaType.convertFromJavaTypes(parameterTypes), parameterNames, bodyBuilder); methodBuilder.setAnnotations(annotations); return methodBuilder.build(); }
/** @return a test for the find all method, if available and requested (may return null) */ private MethodMetadataBuilder getFindAllMethodTest( final MemberTypeAdditions findAllMethod, final MemberTypeAdditions countMethod) { if (!annotationValues.isFindAll() || findAllMethod == null || countMethod == null) { // User does not want this method, or core dependencies are missing return null; } // Prepare method signature JavaSymbolName methodName = new JavaSymbolName("test" + StringUtils.capitalize(findAllMethod.getMethodName())); if (governorHasMethod(methodName)) { return null; } builder.getImportRegistrationResolver().addImport(LIST); List<AnnotationMetadataBuilder> annotations = new ArrayList<AnnotationMetadataBuilder>(); annotations.add(new AnnotationMetadataBuilder(TEST)); final String entityName = annotationValues.getEntity().getSimpleTypeName(); InvocableMemberBodyBuilder bodyBuilder = new InvocableMemberBodyBuilder(); bodyBuilder.appendFormalLine( "Assert.assertNotNull(\"Data on demand for '" + entityName + "' failed to initialize correctly\", dod." + dataOnDemandMetadata.getRandomPersistentEntityMethod().getMethodName().getSymbolName() + "());"); bodyBuilder.appendFormalLine("long count = " + countMethod.getMethodCall() + ";"); bodyBuilder.appendFormalLine( "Assert.assertTrue(\"Too expensive to perform a find all test for '" + entityName + "', as there are \" + count + \" entries; set the findAllMaximum to exceed this value or set findAll=false on the integration test annotation to disable the test\", count < " + annotationValues.getFindAllMaximum() + ");"); bodyBuilder.appendFormalLine( "List<" + entityName + "> result = " + findAllMethod.getMethodCall() + ";"); bodyBuilder.appendFormalLine( "Assert.assertNotNull(\"Find all method for '" + entityName + "' illegally returned null\", result);"); bodyBuilder.appendFormalLine( "Assert.assertTrue(\"Find all method for '" + entityName + "' failed to return any data\", result.size() > 0);"); findAllMethod.copyAdditionsTo(builder, governorTypeDetails); countMethod.copyAdditionsTo(builder, governorTypeDetails); MethodMetadataBuilder methodBuilder = new MethodMetadataBuilder( getId(), Modifier.PUBLIC, methodName, JavaType.VOID_PRIMITIVE, bodyBuilder); methodBuilder.setAnnotations(annotations); return methodBuilder; }
private MethodMetadata getSampleMethod() { // Specify the desired method name JavaSymbolName methodName = new JavaSymbolName("sampleMethod"); // Check if a method with the same signature already exists in the // target type final MethodMetadata method = methodExists(methodName, new ArrayList<AnnotatedJavaType>()); if (method != null) { // If it already exists, just return the method and omit its // generation via the ITD return method; } // Define method annotations (none in this case) List<AnnotationMetadataBuilder> annotations = new ArrayList<AnnotationMetadataBuilder>(); // Define method throws types (none in this case) List<JavaType> throwsTypes = new ArrayList<JavaType>(); // Define method parameter types (none in this case) List<AnnotatedJavaType> parameterTypes = new ArrayList<AnnotatedJavaType>(); // Define method parameter names (none in this case) List<JavaSymbolName> parameterNames = new ArrayList<JavaSymbolName>(); // Create the method body InvocableMemberBodyBuilder bodyBuilder = new InvocableMemberBodyBuilder(); bodyBuilder.appendFormalLine("System.out.println(\"Hello World\");"); // Use the MethodMetadataBuilder for easy creation of MethodMetadata MethodMetadataBuilder methodBuilder = new MethodMetadataBuilder( getId(), Modifier.PUBLIC, methodName, JavaType.VOID_PRIMITIVE, parameterTypes, parameterNames, bodyBuilder); methodBuilder.setAnnotations(annotations); methodBuilder.setThrowsTypes(throwsTypes); return methodBuilder.build(); // Build and return a MethodMetadata // instance }
private MethodMetadata getFromJsonMethod() { JavaSymbolName methodName = getFromJsonMethodName(); if (methodName == null) { return null; } final JavaType parameterType = JavaType.STRING; MethodMetadata result = getGovernorMethod(methodName, parameterType); if (result != null) { return result; } InvocableMemberBodyBuilder bodyBuilder = new InvocableMemberBodyBuilder(); String deserializer = new JavaType("flexjson.JSONDeserializer") .getNameIncludingTypeParameters(false, builder.getImportRegistrationResolver()); bodyBuilder.appendFormalLine( "return new " + deserializer + "<" + destination.getSimpleTypeName() + ">().use(null, " + destination.getSimpleTypeName() + ".class).deserialize(json);"); List<JavaSymbolName> parameterNames = Arrays.asList(new JavaSymbolName("json")); MethodMetadataBuilder methodBuilder = new MethodMetadataBuilder( getId(), Modifier.PUBLIC | Modifier.STATIC, methodName, destination, AnnotatedJavaType.convertFromJavaTypes(parameterType), parameterNames, bodyBuilder); methodBuilder.putCustomData(CustomDataJsonTags.FROM_JSON_METHOD, null); return methodBuilder.build(); }
private MethodMetadata getToJsonMethod() { // Compute the relevant method name JavaSymbolName methodName = getToJsonMethodName(); if (methodName == null) { return null; } // See if the type itself declared the method MethodMetadata result = MemberFindingUtils.getDeclaredMethod(governorTypeDetails, methodName, null); if (result != null) { return result; } InvocableMemberBodyBuilder bodyBuilder = new InvocableMemberBodyBuilder(); String serializer = new JavaType("flexjson.JSONSerializer") .getNameIncludingTypeParameters(false, builder.getImportRegistrationResolver()); String root = annotationValues.getRootName() != null && annotationValues.getRootName().length() > 0 ? ".rootName(\"" + annotationValues.getRootName() + "\")" : ""; bodyBuilder.appendFormalLine( "return new " + serializer + "()" + root + ".exclude(\"*.class\")" + (annotationValues.isDeepSerialize() ? ".deepSerialize(this)" : ".serialize(this)") + ";"); MethodMetadataBuilder methodBuilder = new MethodMetadataBuilder( getId(), Modifier.PUBLIC, methodName, new JavaType("java.lang.String"), bodyBuilder); methodBuilder.putCustomData(CustomDataJsonTags.TO_JSON_METHOD, null); return methodBuilder.build(); }
/** * Obtains the "toString" method for this type, if available. * * <p>If the user provided a non-default name for "toString", that method will be returned. * * @return the "toString" method declared on this type or that will be introduced (or null if * undeclared and not introduced) */ public MethodMetadata getToStringMethod() { // Compute the relevant toString method name JavaSymbolName methodName = new JavaSymbolName("toString"); if (!this.toStringMethod.equals("")) { methodName = new JavaSymbolName(this.toStringMethod); } // See if the type itself declared the method MethodMetadata result = MemberFindingUtils.getDeclaredMethod(governorTypeDetails, methodName, null); if (result != null) { return result; } // Decide whether we need to produce the toString method if (this.toStringMethod.equals("")) { return null; } InvocableMemberBodyBuilder bodyBuilder = new InvocableMemberBodyBuilder(); bodyBuilder.appendFormalLine("StringBuilder sb = new StringBuilder();"); /** Key: field name, Value: accessor name */ Map<String, String> map = new LinkedHashMap<String, String>(); /** Field names */ List<String> order = new ArrayList<String>(); Set<String> excludeFieldsSet = new LinkedHashSet<String>(); if (excludeFields != null && excludeFields.length > 0) { Collections.addAll(excludeFieldsSet, excludeFields); } for (MethodMetadata accessor : locatedAccessors) { String accessorName = accessor.getMethodName().getSymbolName(); String fieldName = BeanInfoUtils.getPropertyNameForJavaBeanMethod(accessor).getSymbolName(); if (!excludeFieldsSet.contains(StringUtils.uncapitalize(fieldName)) && !map.containsKey(fieldName)) { String accessorText = accessorName + "()"; if (accessor.getReturnType().isCommonCollectionType()) { accessorText = accessorName + "() == null ? \"null\" : " + accessorName + "().size()"; } else if (accessor.getReturnType().isArray()) { accessorText = "java.util.Arrays.toString(" + accessorName + "())"; } else if (Calendar.class .getName() .equals(accessor.getReturnType().getFullyQualifiedTypeName())) { accessorText = accessorName + "() == null ? \"null\" : " + accessorName + "().getTime()"; } map.put(fieldName, accessorText); order.add(fieldName); } } if (!order.isEmpty()) { int index = 0; int size = map.keySet().size(); for (String fieldName : order) { index++; String accessorText = map.get(fieldName); StringBuilder string = new StringBuilder(); string .append("sb.append(\"") .append(fieldName) .append(": \").append(") .append(accessorText) .append(")"); if (index < size) { string.append(".append(\", \")"); } string.append(";"); bodyBuilder.appendFormalLine(string.toString()); } bodyBuilder.appendFormalLine("return sb.toString();"); MethodMetadataBuilder methodBuilder = new MethodMetadataBuilder(getId(), Modifier.PUBLIC, methodName, STRING, bodyBuilder); result = methodBuilder.build(); } return result; }
private MethodMetadataBuilder getFinderFormMethod(final FinderMetadataDetails finder) { Validate.notNull(finder, "Method metadata required for finder"); final JavaSymbolName finderFormMethodName = new JavaSymbolName( finder.getFinderMethodMetadata().getMethodName().getSymbolName() + "Form"); final List<JavaType> methodParameterTypes = new ArrayList<JavaType>(); final List<JavaSymbolName> methodParameterNames = new ArrayList<JavaSymbolName>(); final List<JavaType> finderParameterTypes = AnnotatedJavaType.convertFromAnnotatedJavaTypes( finder.getFinderMethodMetadata().getParameterTypes()); final InvocableMemberBodyBuilder bodyBuilder = new InvocableMemberBodyBuilder(); boolean needModel = false; for (final JavaType finderParameterType : finderParameterTypes) { JavaTypeMetadataDetails typeMd = specialDomainTypes.get(finderParameterType); JavaTypePersistenceMetadataDetails javaTypePersistenceMetadataHolder = null; if (finderParameterType.isCommonCollectionType()) { typeMd = specialDomainTypes.get(finderParameterType.getParameters().get(0)); if (typeMd != null && typeMd.isApplicationType()) { javaTypePersistenceMetadataHolder = typeMd.getPersistenceDetails(); } } else if (typeMd != null && typeMd.isEnumType()) { bodyBuilder.appendFormalLine( "uiModel.addAttribute(\"" + typeMd.getPlural().toLowerCase() + "\", java.util.Arrays.asList(" + getShortName(finderParameterType) + ".class.getEnumConstants()));"); } else if (typeMd != null && typeMd.isApplicationType()) { javaTypePersistenceMetadataHolder = typeMd.getPersistenceDetails(); } if (typeMd != null && javaTypePersistenceMetadataHolder != null && javaTypePersistenceMetadataHolder.getFindAllMethod() != null) { bodyBuilder.appendFormalLine( "uiModel.addAttribute(\"" + typeMd.getPlural().toLowerCase() + "\", " + javaTypePersistenceMetadataHolder.getFindAllMethod().getMethodCall() + ");"); } needModel = true; } if (finderParameterTypes.contains(DATE) || finderParameterTypes.contains(CALENDAR)) { bodyBuilder.appendFormalLine("addDateTimeFormatPatterns(uiModel);"); } bodyBuilder.appendFormalLine( "return \"" + controllerPath + "/" + finder.getFinderMethodMetadata().getMethodName().getSymbolName() + "\";"); if (needModel) { methodParameterTypes.add(MODEL); methodParameterNames.add(new JavaSymbolName("uiModel")); } if (governorHasMethod(finderFormMethodName, methodParameterTypes)) { return null; } final List<AnnotationAttributeValue<?>> requestMappingAttributes = new ArrayList<AnnotationAttributeValue<?>>(); final List<StringAttributeValue> arrayValues = new ArrayList<StringAttributeValue>(); arrayValues.add( new StringAttributeValue( new JavaSymbolName("value"), "find=" + finder .getFinderMethodMetadata() .getMethodName() .getSymbolName() .replaceFirst("find" + javaTypeMetadataHolder.getPlural(), ""))); arrayValues.add(new StringAttributeValue(new JavaSymbolName("value"), "form")); requestMappingAttributes.add( new ArrayAttributeValue<StringAttributeValue>(new JavaSymbolName("params"), arrayValues)); requestMappingAttributes.add( new EnumAttributeValue( new JavaSymbolName("method"), new EnumDetails(REQUEST_METHOD, new JavaSymbolName("GET")))); final AnnotationMetadataBuilder requestMapping = new AnnotationMetadataBuilder(REQUEST_MAPPING, requestMappingAttributes); final List<AnnotationMetadataBuilder> annotations = new ArrayList<AnnotationMetadataBuilder>(); annotations.add(requestMapping); final MethodMetadataBuilder methodBuilder = new MethodMetadataBuilder( getId(), Modifier.PUBLIC, finderFormMethodName, JavaType.STRING, AnnotatedJavaType.convertFromJavaTypes(methodParameterTypes), methodParameterNames, bodyBuilder); methodBuilder.setAnnotations(annotations); return methodBuilder; }
/** @return a test for the persist method, if available and requested (may return null) */ private MethodMetadataBuilder getPersistMethodTest( final MemberTypeAdditions persistMethod, final MemberTypeAdditions flushMethod, final MethodMetadata identifierAccessorMethod) { if (!annotationValues.isPersist() || persistMethod == null || identifierAccessorMethod == null) { // User does not want this method return null; } // Prepare method signature JavaSymbolName methodName = new JavaSymbolName("test" + StringUtils.capitalize(persistMethod.getMethodName())); if (governorHasMethod(methodName)) { return null; } List<AnnotationMetadataBuilder> annotations = new ArrayList<AnnotationMetadataBuilder>(); annotations.add(new AnnotationMetadataBuilder(TEST)); final String entityName = annotationValues.getEntity().getSimpleTypeName(); InvocableMemberBodyBuilder bodyBuilder = new InvocableMemberBodyBuilder(); bodyBuilder.appendFormalLine( "Assert.assertNotNull(\"Data on demand for '" + entityName + "' failed to initialize correctly\", dod." + dataOnDemandMetadata.getRandomPersistentEntityMethod().getMethodName().getSymbolName() + "());"); bodyBuilder.appendFormalLine( entityName + " obj = dod." + dataOnDemandMetadata.getNewTransientEntityMethod().getMethodName().getSymbolName() + "(Integer.MAX_VALUE);"); bodyBuilder.appendFormalLine( "Assert.assertNotNull(\"Data on demand for '" + entityName + "' failed to provide a new transient entity\", obj);"); if (!hasEmbeddedIdentifier) { bodyBuilder.appendFormalLine( "Assert.assertNull(\"Expected '" + entityName + "' identifier to be null\", obj." + identifierAccessorMethod.getMethodName().getSymbolName() + "());"); } bodyBuilder.appendFormalLine(persistMethod.getMethodCall() + ";"); if (flushMethod != null) { bodyBuilder.appendFormalLine(flushMethod.getMethodCall() + ";"); flushMethod.copyAdditionsTo(builder, governorTypeDetails); } bodyBuilder.appendFormalLine( "Assert.assertNotNull(\"Expected '" + entityName + "' identifier to no longer be null\", obj." + identifierAccessorMethod.getMethodName().getSymbolName() + "());"); persistMethod.copyAdditionsTo(builder, governorTypeDetails); MethodMetadataBuilder methodBuilder = new MethodMetadataBuilder( getId(), Modifier.PUBLIC, methodName, JavaType.VOID_PRIMITIVE, bodyBuilder); methodBuilder.setAnnotations(annotations); return methodBuilder; }
/** @return a test for the persist method, if available and requested (may return null) */ private MethodMetadataBuilder getRemoveMethodTest( final MemberTypeAdditions removeMethod, final MemberTypeAdditions findMethod, final MemberTypeAdditions flushMethod, final MethodMetadata identifierAccessorMethod) { if (!annotationValues.isRemove() || removeMethod == null || findMethod == null || identifierAccessorMethod == null) { // User does not want this method or one of its core dependencies return null; } // Prepare method signature JavaSymbolName methodName = new JavaSymbolName("test" + StringUtils.capitalize(removeMethod.getMethodName())); if (governorHasMethod(methodName)) { return null; } builder.getImportRegistrationResolver().addImport(identifierAccessorMethod.getReturnType()); List<AnnotationMetadataBuilder> annotations = new ArrayList<AnnotationMetadataBuilder>(); annotations.add(new AnnotationMetadataBuilder(TEST)); if (isGaeSupported) { AnnotationMetadataBuilder transactionalBuilder = new AnnotationMetadataBuilder(TRANSACTIONAL); if (StringUtils.hasText(transactionManager) && !"transactionManager".equals(transactionManager)) { transactionalBuilder.addStringAttribute("value", transactionManager); } transactionalBuilder.addEnumAttribute( "propagation", new EnumDetails(PROPAGATION, new JavaSymbolName("SUPPORTS"))); annotations.add(transactionalBuilder); } final String entityName = annotationValues.getEntity().getSimpleTypeName(); InvocableMemberBodyBuilder bodyBuilder = new InvocableMemberBodyBuilder(); bodyBuilder.appendFormalLine( entityName + " obj = dod." + dataOnDemandMetadata.getRandomPersistentEntityMethod().getMethodName().getSymbolName() + "();"); bodyBuilder.appendFormalLine( "Assert.assertNotNull(\"Data on demand for '" + entityName + "' failed to initialize correctly\", obj);"); bodyBuilder.appendFormalLine( identifierAccessorMethod.getReturnType().getSimpleTypeName() + " id = obj." + identifierAccessorMethod.getMethodName().getSymbolName() + "();"); bodyBuilder.appendFormalLine( "Assert.assertNotNull(\"Data on demand for '" + entityName + "' failed to provide an identifier\", id);"); bodyBuilder.appendFormalLine("obj = " + findMethod.getMethodCall() + ";"); bodyBuilder.appendFormalLine(removeMethod.getMethodCall() + ";"); if (flushMethod != null) { bodyBuilder.appendFormalLine(flushMethod.getMethodCall() + ";"); flushMethod.copyAdditionsTo(builder, governorTypeDetails); } bodyBuilder.appendFormalLine( "Assert.assertNull(\"Failed to remove '" + entityName + "' with identifier '\" + id + \"'\", " + findMethod.getMethodCall() + ");"); removeMethod.copyAdditionsTo(builder, governorTypeDetails); findMethod.copyAdditionsTo(builder, governorTypeDetails); MethodMetadataBuilder methodBuilder = new MethodMetadataBuilder( getId(), Modifier.PUBLIC, methodName, JavaType.VOID_PRIMITIVE, bodyBuilder); methodBuilder.setAnnotations(annotations); return methodBuilder; }
private MethodMetadata getDelegateMethod( final JavaSymbolName methodName, final String methodDelegateName) { // Method definition to find or build final JavaType[] parameterTypes = {}; // Locate user-defined method final MethodMetadata userMethod = getGovernorMethod(methodName, parameterTypes); if (userMethod != null) { return userMethod; } // Create the method final List<AnnotationMetadataBuilder> annotations = new ArrayList<AnnotationMetadataBuilder>(); final InvocableMemberBodyBuilder bodyBuilder = new InvocableMemberBodyBuilder(); // Address non-injected entity manager field final MethodMetadata entityManagerMethod = getEntityManagerMethod(); Assert.notNull(entityManagerMethod, "Entity manager method should not have returned null"); // Use the getEntityManager() method to acquire an entity manager (the method will throw an // exception if it cannot be acquired) final String entityManagerFieldName = getEntityManagerField().getFieldName().getSymbolName(); bodyBuilder.appendFormalLine( "if (this." + entityManagerFieldName + " == null) this." + entityManagerFieldName + " = " + entityManagerMethod.getMethodName().getSymbolName() + "();"); JavaType returnType = JavaType.VOID_PRIMITIVE; if ("flush".equals(methodDelegateName)) { addTransactionalAnnotation(annotations); bodyBuilder.appendFormalLine("this." + entityManagerFieldName + ".flush();"); } else if ("clear".equals(methodDelegateName)) { addTransactionalAnnotation(annotations); bodyBuilder.appendFormalLine("this." + entityManagerFieldName + ".clear();"); } else if ("merge".equals(methodDelegateName)) { addTransactionalAnnotation(annotations); returnType = new JavaType(destination.getSimpleTypeName()); bodyBuilder.appendFormalLine( destination.getSimpleTypeName() + " merged = this." + entityManagerFieldName + ".merge(this);"); bodyBuilder.appendFormalLine("this." + entityManagerFieldName + ".flush();"); bodyBuilder.appendFormalLine("return merged;"); } else if ("remove".equals(methodDelegateName)) { addTransactionalAnnotation(annotations); bodyBuilder.appendFormalLine("if (this." + entityManagerFieldName + ".contains(this)) {"); bodyBuilder.indent(); bodyBuilder.appendFormalLine("this." + entityManagerFieldName + ".remove(this);"); bodyBuilder.indentRemove(); bodyBuilder.appendFormalLine("} else {"); bodyBuilder.indent(); bodyBuilder.appendFormalLine( destination.getSimpleTypeName() + " attached = " + destination.getSimpleTypeName() + "." + getFindMethod().getMethodName().getSymbolName() + "(this." + identifierField.getFieldName().getSymbolName() + ");"); bodyBuilder.appendFormalLine("this." + entityManagerFieldName + ".remove(attached);"); bodyBuilder.indentRemove(); bodyBuilder.appendFormalLine("}"); } else { // Persist addTransactionalAnnotation(annotations, true); bodyBuilder.appendFormalLine( "this." + entityManagerFieldName + "." + methodDelegateName + "(this);"); } final MethodMetadataBuilder methodBuilder = new MethodMetadataBuilder( getId(), Modifier.PUBLIC, methodName, returnType, AnnotatedJavaType.convertFromJavaTypes(parameterTypes), new ArrayList<JavaSymbolName>(), bodyBuilder); methodBuilder.setAnnotations(annotations); return methodBuilder.build(); }
/** @return a test for the merge method, if available and requested (may return null) */ private MethodMetadataBuilder getMergeMethodTest( final MemberTypeAdditions mergeMethod, final MemberTypeAdditions findMethod, final MemberTypeAdditions flushMethod, final MethodMetadata versionAccessorMethod, final MethodMetadata identifierAccessorMethod) { if (!annotationValues.isMerge() || mergeMethod == null || versionAccessorMethod == null || findMethod == null || identifierAccessorMethod == null) { // User does not want this method, or core dependencies are missing return null; } // Prepare method signature JavaSymbolName methodName = new JavaSymbolName("test" + StringUtils.capitalize(mergeMethod.getMethodName()) + "Update"); if (governorHasMethod(methodName)) { return null; } JavaType versionType = versionAccessorMethod.getReturnType(); builder .getImportRegistrationResolver() .addImports(identifierAccessorMethod.getReturnType(), versionType); List<AnnotationMetadataBuilder> annotations = new ArrayList<AnnotationMetadataBuilder>(); annotations.add(new AnnotationMetadataBuilder(TEST)); String entityName = annotationValues.getEntity().getSimpleTypeName(); InvocableMemberBodyBuilder bodyBuilder = new InvocableMemberBodyBuilder(); bodyBuilder.appendFormalLine( entityName + " obj = dod." + dataOnDemandMetadata.getRandomPersistentEntityMethod().getMethodName().getSymbolName() + "();"); bodyBuilder.appendFormalLine( "Assert.assertNotNull(\"Data on demand for '" + entityName + "' failed to initialize correctly\", obj);"); bodyBuilder.appendFormalLine( identifierAccessorMethod.getReturnType().getSimpleTypeName() + " id = obj." + identifierAccessorMethod.getMethodName().getSymbolName() + "();"); bodyBuilder.appendFormalLine( "Assert.assertNotNull(\"Data on demand for '" + entityName + "' failed to provide an identifier\", id);"); bodyBuilder.appendFormalLine("obj = " + findMethod.getMethodCall() + ";"); bodyBuilder.appendFormalLine( "boolean modified = dod." + dataOnDemandMetadata.getModifyMethod().getMethodName().getSymbolName() + "(obj);"); bodyBuilder.appendFormalLine( versionAccessorMethod.getReturnType().getSimpleTypeName() + " currentVersion = obj." + versionAccessorMethod.getMethodName().getSymbolName() + "();"); String castStr = entityHasSuperclass ? "(" + entityName + ")" : ""; bodyBuilder.appendFormalLine( entityName + " merged = " + castStr + mergeMethod.getMethodCall() + ";"); if (flushMethod != null) { bodyBuilder.appendFormalLine(flushMethod.getMethodCall() + ";"); flushMethod.copyAdditionsTo(builder, governorTypeDetails); } bodyBuilder.appendFormalLine( "Assert.assertEquals(\"Identifier of merged object not the same as identifier of original object\", merged." + identifierAccessorMethod.getMethodName().getSymbolName() + "(), id);"); if (JdkJavaType.isDateField(versionType)) { bodyBuilder.appendFormalLine( "Assert.assertTrue(\"Version for '" + entityName + "' failed to increment on merge and flush directive\", (currentVersion != null && obj." + versionAccessorMethod.getMethodName().getSymbolName() + "().after(currentVersion)) || !modified);"); } else { bodyBuilder.appendFormalLine( "Assert.assertTrue(\"Version for '" + entityName + "' failed to increment on merge and flush directive\", (currentVersion != null && obj." + versionAccessorMethod.getMethodName().getSymbolName() + "() > currentVersion) || !modified);"); } mergeMethod.copyAdditionsTo(builder, governorTypeDetails); findMethod.copyAdditionsTo(builder, governorTypeDetails); MethodMetadataBuilder methodBuilder = new MethodMetadataBuilder( getId(), Modifier.PUBLIC, methodName, JavaType.VOID_PRIMITIVE, bodyBuilder); methodBuilder.setAnnotations(annotations); return methodBuilder; }
/** * @return the static utility entityManager() method used by other methods to obtain entity * manager and available as a utility for user code (never returns nulls) */ public MethodMetadata getEntityManagerMethod() { if (parent != null) { // The parent is required to guarantee this is available return parent.getEntityManagerMethod(); } // Method definition to find or build final JavaSymbolName methodName = new JavaSymbolName(ENTITY_MANAGER_METHOD_NAME); final JavaType[] parameterTypes = {}; final JavaType returnType = ENTITY_MANAGER; // Locate user-defined method final MethodMetadata userMethod = getGovernorMethod(methodName, parameterTypes); if (userMethod != null) { Assert.isTrue( userMethod.getReturnType().equals(returnType), "Method '" + methodName + "' on '" + destination + "' must return '" + returnType.getNameIncludingTypeParameters() + "'"); return userMethod; } // Create method final InvocableMemberBodyBuilder bodyBuilder = new InvocableMemberBodyBuilder(); if (Modifier.isAbstract(governorTypeDetails.getModifier())) { // Create an anonymous inner class that extends the abstract class (no-arg constructor is // available as this is a JPA entity) bodyBuilder.appendFormalLine( ENTITY_MANAGER.getNameIncludingTypeParameters( false, builder.getImportRegistrationResolver()) + " em = new " + destination.getSimpleTypeName() + "() {"); // Handle any abstract methods in this class bodyBuilder.indent(); for (final MethodMetadata method : governorTypeDetails.getMethods()) { if (Modifier.isAbstract(method.getModifier())) { final StringBuilder params = new StringBuilder(); int i = -1; final List<AnnotatedJavaType> types = method.getParameterTypes(); for (final JavaSymbolName name : method.getParameterNames()) { i++; if (i > 0) { params.append(", "); } final AnnotatedJavaType type = types.get(i); params.append(type.toString()).append(" ").append(name); } final int newModifier = method.getModifier() - Modifier.ABSTRACT; bodyBuilder.appendFormalLine( Modifier.toString(newModifier) + " " + method.getReturnType().getNameIncludingTypeParameters() + " " + method.getMethodName().getSymbolName() + "(" + params.toString() + ") {"); bodyBuilder.indent(); bodyBuilder.appendFormalLine("throw new UnsupportedOperationException();"); bodyBuilder.indentRemove(); bodyBuilder.appendFormalLine("}"); } } bodyBuilder.indentRemove(); bodyBuilder.appendFormalLine( "}." + getEntityManagerField().getFieldName().getSymbolName() + ";"); } else { // Instantiate using the no-argument constructor (we know this is available as the entity must // comply with the JPA no-arg constructor requirement) bodyBuilder.appendFormalLine( ENTITY_MANAGER.getNameIncludingTypeParameters( false, builder.getImportRegistrationResolver()) + " em = new " + destination.getSimpleTypeName() + "()." + getEntityManagerField().getFieldName().getSymbolName() + ";"); } bodyBuilder.appendFormalLine( "if (em == null) throw new IllegalStateException(\"Entity manager has not been injected (is the Spring Aspects JAR configured as an AJC/AJDT aspects library?)\");"); bodyBuilder.appendFormalLine("return em;"); final int modifier = Modifier.PUBLIC | Modifier.STATIC | Modifier.FINAL; final MethodMetadataBuilder methodBuilder = new MethodMetadataBuilder( getId(), modifier, methodName, returnType, AnnotatedJavaType.convertFromJavaTypes(parameterTypes), new ArrayList<JavaSymbolName>(), bodyBuilder); return methodBuilder.build(); }
/** @return the find (by ID) method (may return null) */ public MethodMetadata getFindMethod() { if ("".equals(crudAnnotationValues.getFindMethod())) { return null; } // Method definition to find or build final String idFieldName = identifierField.getFieldName().getSymbolName(); final JavaSymbolName methodName = new JavaSymbolName(crudAnnotationValues.getFindMethod() + destination.getSimpleTypeName()); final JavaType parameterType = identifierField.getFieldType(); final List<JavaSymbolName> parameterNames = Arrays.asList(new JavaSymbolName(idFieldName)); final JavaType returnType = destination; // Locate user-defined method final MethodMetadata userMethod = getGovernorMethod(methodName, parameterType); if (userMethod != null) { Assert.isTrue( userMethod.getReturnType().equals(returnType), "Method '" + methodName + "' on '" + returnType + "' must return '" + returnType.getNameIncludingTypeParameters() + "'"); return userMethod; } // Create method final List<AnnotationMetadataBuilder> annotations = new ArrayList<AnnotationMetadataBuilder>(); if (isGaeEnabled) { addTransactionalAnnotation(annotations); } final InvocableMemberBodyBuilder bodyBuilder = new InvocableMemberBodyBuilder(); if (JavaType.STRING.equals(identifierField.getFieldType())) { bodyBuilder.appendFormalLine( "if (" + idFieldName + " == null || " + idFieldName + ".length() == 0) return null;"); } else if (!identifierField.getFieldType().isPrimitive()) { bodyBuilder.appendFormalLine("if (" + idFieldName + " == null) return null;"); } bodyBuilder.appendFormalLine( "return " + ENTITY_MANAGER_METHOD_NAME + "().find(" + returnType.getSimpleTypeName() + ".class, " + idFieldName + ");"); final MethodMetadataBuilder methodBuilder = new MethodMetadataBuilder( getId(), Modifier.PUBLIC | Modifier.STATIC, methodName, returnType, AnnotatedJavaType.convertFromJavaTypes(parameterType), parameterNames, bodyBuilder); methodBuilder.setAnnotations(annotations); return methodBuilder.build(); }
/** * Generates the "send email" method to be added to the domain type * * @param mailSenderName the name of the MailSender field (required) * @param async whether to send the email asynchronously * @param targetClassMID the MID of the class to receive the method * @param mutableTypeDetails the type to which the method is being added (required) * @return a non-<code>null</code> method */ private MethodMetadata getSendMethod( final JavaSymbolName mailSenderName, final boolean async, final String targetClassMID, final ClassOrInterfaceTypeDetailsBuilder classOrInterfaceTypeDetailsBuilder) { final String contextPath = getApplicationContextPath(); final Document document = XmlUtils.readXml(fileManager.getInputStream(contextPath)); final Element root = document.getDocumentElement(); // Make a builder for the created method's body final InvocableMemberBodyBuilder bodyBuilder = new InvocableMemberBodyBuilder(); // Collect the types and names of the created method's parameters final PairList<AnnotatedJavaType, JavaSymbolName> parameters = new PairList<AnnotatedJavaType, JavaSymbolName>(); if (getSimpleMailMessageBean(root) == null) { // There's no SimpleMailMessage bean; use a local variable bodyBuilder.appendFormalLine( "org.springframework.mail.SimpleMailMessage " + LOCAL_MESSAGE_VARIABLE + " = new org.springframework.mail.SimpleMailMessage();"); // Set the from address parameters.add(STRING, new JavaSymbolName("mailFrom")); bodyBuilder.appendFormalLine(LOCAL_MESSAGE_VARIABLE + ".setFrom(mailFrom);"); // Set the subject parameters.add(STRING, new JavaSymbolName("subject")); bodyBuilder.appendFormalLine(LOCAL_MESSAGE_VARIABLE + ".setSubject(subject);"); } else { // A SimpleMailMessage bean exists; auto-wire it into the entity and use it as a template final List<AnnotationMetadataBuilder> smmAnnotations = Arrays.asList(new AnnotationMetadataBuilder(AUTOWIRED)); final FieldMetadataBuilder smmFieldBuilder = new FieldMetadataBuilder( targetClassMID, PRIVATE_TRANSIENT, smmAnnotations, new JavaSymbolName(TEMPLATE_MESSAGE_FIELD), SIMPLE_MAIL_MESSAGE); classOrInterfaceTypeDetailsBuilder.addField(smmFieldBuilder.build()); // Use the injected bean as a template (for thread safety) bodyBuilder.appendFormalLine( "org.springframework.mail.SimpleMailMessage " + LOCAL_MESSAGE_VARIABLE + " = new org.springframework.mail.SimpleMailMessage(" + TEMPLATE_MESSAGE_FIELD + ");"); } // Set the to address parameters.add(STRING, new JavaSymbolName("mailTo")); bodyBuilder.appendFormalLine(LOCAL_MESSAGE_VARIABLE + ".setTo(mailTo);"); // Set the message body parameters.add(STRING, new JavaSymbolName("message")); bodyBuilder.appendFormalLine(LOCAL_MESSAGE_VARIABLE + ".setText(message);"); bodyBuilder.newLine(); bodyBuilder.appendFormalLine(mailSenderName + ".send(" + LOCAL_MESSAGE_VARIABLE + ");"); final MethodMetadataBuilder methodBuilder = new MethodMetadataBuilder( targetClassMID, Modifier.PUBLIC, new JavaSymbolName("sendMessage"), JavaType.VOID_PRIMITIVE, parameters.getKeys(), parameters.getValues(), bodyBuilder); if (async) { if (DomUtils.findFirstElementByName("task:annotation-driven", root) == null) { // Add asynchronous email support to the application if (!StringUtils.hasText(root.getAttribute("xmlns:task"))) { // Add the "task" namespace to the Spring config file root.setAttribute("xmlns:task", SPRING_TASK_NS); root.setAttribute( "xsi:schemaLocation", root.getAttribute("xsi:schemaLocation") + " " + SPRING_TASK_NS + " " + SPRING_TASK_XSD); } root.appendChild( new XmlElementBuilder("task:annotation-driven", document) .addAttribute("executor", "asyncExecutor") .addAttribute("mode", "aspectj") .build()); root.appendChild( new XmlElementBuilder("task:executor", document) .addAttribute("id", "asyncExecutor") .addAttribute("pool-size", "${executor.poolSize}") .build()); // Write out the new Spring config file fileManager.createOrUpdateTextFileIfRequired( contextPath, XmlUtils.nodeToString(document), false); // Update the email properties file propFileOperations.addPropertyIfNotExists( Path.SPRING_CONFIG_ROOT, "email.properties", "executor.poolSize", "10", true); } methodBuilder.addAnnotation(new AnnotationMetadataBuilder(ASYNC)); } return methodBuilder.build(); }
private void addOptionalIntegrationTestClassIntroductions() { // Add the GAE test helper field if the user did not define it on the // governor directly final JavaType helperType = GAE_LOCAL_SERVICE_TEST_HELPER; FieldMetadata helperField = governorTypeDetails.getField(new JavaSymbolName("helper")); if (helperField != null) { Assert.isTrue( helperField .getFieldType() .getFullyQualifiedTypeName() .equals(helperType.getFullyQualifiedTypeName()), "Field 'helper' on '" + destination.getFullyQualifiedTypeName() + "' must be of type '" + helperType.getFullyQualifiedTypeName() + "'"); } else { // Add the field via the ITD String initializer = "new LocalServiceTestHelper(new com.google.appengine.tools.development.testing.LocalDatastoreServiceTestConfig())"; FieldMetadataBuilder fieldBuilder = new FieldMetadataBuilder( getId(), Modifier.PRIVATE | Modifier.STATIC | Modifier.FINAL, new JavaSymbolName("helper"), helperType, initializer); builder.addField(fieldBuilder); } // Prepare setUp method signature JavaSymbolName setUpMethodName = new JavaSymbolName("setUp"); MethodMetadata setUpMethod = getGovernorMethod(setUpMethodName, SETUP_PARAMETERS); if (setUpMethod != null) { Assert.notNull( MemberFindingUtils.getAnnotationOfType(setUpMethod.getAnnotations(), BEFORE_CLASS), "Method 'setUp' on '" + destination.getFullyQualifiedTypeName() + "' must be annotated with @BeforeClass"); } else { // Add the method via the ITD List<AnnotationMetadataBuilder> annotations = new ArrayList<AnnotationMetadataBuilder>(); annotations.add(new AnnotationMetadataBuilder(BEFORE_CLASS)); InvocableMemberBodyBuilder bodyBuilder = new InvocableMemberBodyBuilder(); bodyBuilder.appendFormalLine("helper.setUp();"); MethodMetadataBuilder methodBuilder = new MethodMetadataBuilder( getId(), Modifier.PUBLIC | Modifier.STATIC, setUpMethodName, JavaType.VOID_PRIMITIVE, AnnotatedJavaType.convertFromJavaTypes(SETUP_PARAMETERS), new ArrayList<JavaSymbolName>(), bodyBuilder); methodBuilder.setAnnotations(annotations); builder.addMethod(methodBuilder); } // Prepare tearDown method signature JavaSymbolName tearDownMethodName = new JavaSymbolName("tearDown"); MethodMetadata tearDownMethod = getGovernorMethod(tearDownMethodName, TEARDOWN_PARAMETERS); if (tearDownMethod != null) { Assert.notNull( MemberFindingUtils.getAnnotationOfType(tearDownMethod.getAnnotations(), AFTER_CLASS), "Method 'tearDown' on '" + destination.getFullyQualifiedTypeName() + "' must be annotated with @AfterClass"); } else { // Add the method via the ITD List<AnnotationMetadataBuilder> annotations = new ArrayList<AnnotationMetadataBuilder>(); annotations.add(new AnnotationMetadataBuilder(AFTER_CLASS)); InvocableMemberBodyBuilder bodyBuilder = new InvocableMemberBodyBuilder(); bodyBuilder.appendFormalLine("helper.tearDown();"); MethodMetadataBuilder methodBuilder = new MethodMetadataBuilder( getId(), Modifier.PUBLIC | Modifier.STATIC, tearDownMethodName, JavaType.VOID_PRIMITIVE, AnnotatedJavaType.convertFromJavaTypes(TEARDOWN_PARAMETERS), new ArrayList<JavaSymbolName>(), bodyBuilder); methodBuilder.setAnnotations(annotations); builder.addMethod(methodBuilder); } }
private MethodMetadataBuilder getFinderMethod(final FinderMetadataDetails finderMetadataDetails) { Validate.notNull(finderMetadataDetails, "Method metadata required for finder"); final JavaSymbolName finderMethodName = new JavaSymbolName( finderMetadataDetails.getFinderMethodMetadata().getMethodName().getSymbolName()); final List<AnnotatedJavaType> parameterTypes = new ArrayList<AnnotatedJavaType>(); final List<JavaSymbolName> parameterNames = new ArrayList<JavaSymbolName>(); final InvocableMemberBodyBuilder bodyBuilder = new InvocableMemberBodyBuilder(); final StringBuilder methodParams = new StringBuilder(); boolean dateFieldPresent = !dateTypes.isEmpty(); for (final FieldMetadata field : finderMetadataDetails.getFinderMethodParamFields()) { final JavaSymbolName fieldName = field.getFieldName(); final List<AnnotationMetadata> annotations = new ArrayList<AnnotationMetadata>(); final List<AnnotationAttributeValue<?>> attributes = new ArrayList<AnnotationAttributeValue<?>>(); attributes.add( new StringAttributeValue( new JavaSymbolName("value"), uncapitalize(fieldName.getSymbolName()))); if (field.getFieldType().equals(JavaType.BOOLEAN_PRIMITIVE) || field.getFieldType().equals(JavaType.BOOLEAN_OBJECT)) { attributes.add(new BooleanAttributeValue(new JavaSymbolName("required"), false)); } final AnnotationMetadataBuilder requestParamAnnotation = new AnnotationMetadataBuilder(REQUEST_PARAM, attributes); annotations.add(requestParamAnnotation.build()); if (field.getFieldType().equals(DATE) || field.getFieldType().equals(CALENDAR)) { dateFieldPresent = true; final AnnotationMetadata annotation = MemberFindingUtils.getAnnotationOfType(field.getAnnotations(), DATE_TIME_FORMAT); if (annotation != null) { getShortName(DATE_TIME_FORMAT); annotations.add(annotation); } } parameterNames.add(fieldName); parameterTypes.add(new AnnotatedJavaType(field.getFieldType(), annotations)); if (field.getFieldType().equals(JavaType.BOOLEAN_OBJECT)) { methodParams.append(fieldName + " == null ? Boolean.FALSE : " + fieldName + ", "); } else { methodParams.append(fieldName + ", "); } } if (methodParams.length() > 0) { methodParams.delete(methodParams.length() - 2, methodParams.length()); } final List<AnnotationAttributeValue<?>> firstResultAttributes = new ArrayList<AnnotationAttributeValue<?>>(); firstResultAttributes.add(new StringAttributeValue(new JavaSymbolName("value"), "page")); firstResultAttributes.add(new BooleanAttributeValue(new JavaSymbolName("required"), false)); final AnnotationMetadataBuilder firstResultAnnotation = new AnnotationMetadataBuilder(REQUEST_PARAM, firstResultAttributes); final List<AnnotationAttributeValue<?>> maxResultsAttributes = new ArrayList<AnnotationAttributeValue<?>>(); maxResultsAttributes.add(new StringAttributeValue(new JavaSymbolName("value"), "size")); maxResultsAttributes.add(new BooleanAttributeValue(new JavaSymbolName("required"), false)); final AnnotationMetadataBuilder maxResultAnnotation = new AnnotationMetadataBuilder(REQUEST_PARAM, maxResultsAttributes); final List<AnnotationAttributeValue<?>> sortFieldNameAttributes = new ArrayList<AnnotationAttributeValue<?>>(); sortFieldNameAttributes.add( new StringAttributeValue(new JavaSymbolName("value"), "sortFieldName")); sortFieldNameAttributes.add(new BooleanAttributeValue(new JavaSymbolName("required"), false)); final AnnotationMetadataBuilder sortFieldNameAnnotation = new AnnotationMetadataBuilder(REQUEST_PARAM, sortFieldNameAttributes); final List<AnnotationAttributeValue<?>> sortOrderAttributes = new ArrayList<AnnotationAttributeValue<?>>(); sortOrderAttributes.add(new StringAttributeValue(new JavaSymbolName("value"), "sortOrder")); sortOrderAttributes.add(new BooleanAttributeValue(new JavaSymbolName("required"), false)); final AnnotationMetadataBuilder sortOrderAnnotation = new AnnotationMetadataBuilder(REQUEST_PARAM, sortOrderAttributes); parameterTypes.add( new AnnotatedJavaType( new JavaType(Integer.class.getName()), firstResultAnnotation.build())); parameterTypes.add( new AnnotatedJavaType(new JavaType(Integer.class.getName()), maxResultAnnotation.build())); parameterTypes.add( new AnnotatedJavaType( new JavaType(String.class.getName()), sortFieldNameAnnotation.build())); parameterTypes.add( new AnnotatedJavaType(new JavaType(String.class.getName()), sortOrderAnnotation.build())); parameterTypes.add(new AnnotatedJavaType(MODEL)); if (getGovernorMethod( finderMethodName, AnnotatedJavaType.convertFromAnnotatedJavaTypes(parameterTypes)) != null) { return null; } final List<JavaSymbolName> newParamNames = new ArrayList<JavaSymbolName>(); newParamNames.addAll(parameterNames); newParamNames.add(new JavaSymbolName("page")); newParamNames.add(new JavaSymbolName("size")); newParamNames.add(new JavaSymbolName("sortFieldName")); newParamNames.add(new JavaSymbolName("sortOrder")); newParamNames.add(new JavaSymbolName("uiModel")); final List<AnnotationAttributeValue<?>> requestMappingAttributes = new ArrayList<AnnotationAttributeValue<?>>(); requestMappingAttributes.add( new StringAttributeValue( new JavaSymbolName("params"), "find=" + finderMetadataDetails .getFinderMethodMetadata() .getMethodName() .getSymbolName() .replaceFirst("find" + javaTypeMetadataHolder.getPlural(), ""))); requestMappingAttributes.add( new EnumAttributeValue( new JavaSymbolName("method"), new EnumDetails(REQUEST_METHOD, new JavaSymbolName("GET")))); final AnnotationMetadataBuilder requestMapping = new AnnotationMetadataBuilder(REQUEST_MAPPING, requestMappingAttributes); final List<AnnotationMetadataBuilder> annotations = new ArrayList<AnnotationMetadataBuilder>(); annotations.add(requestMapping); bodyBuilder.appendFormalLine("if (page != null || size != null) {"); bodyBuilder.indent(); bodyBuilder.appendFormalLine("int sizeNo = size == null ? 10 : size.intValue();"); bodyBuilder.appendFormalLine( "final int firstResult = page == null ? 0 : (page.intValue() - 1) * sizeNo;"); String methodParamsString = methodParams.toString(); if (StringUtils.isNotBlank(methodParamsString)) { methodParamsString.concat(", "); } bodyBuilder.appendFormalLine( "uiModel.addAttribute(\"" + javaTypeMetadataHolder.getPlural().toLowerCase() + "\", " + getShortName(formBackingType) + "." + finderMetadataDetails.getFinderMethodMetadata().getMethodName().getSymbolName() + "(" + methodParamsString + "sortFieldName, sortOrder).setFirstResult(firstResult).setMaxResults(sizeNo).getResultList());"); char[] methodNameArray = finderMetadataDetails .getFinderMethodMetadata() .getMethodName() .getSymbolName() .toCharArray(); methodNameArray[0] = Character.toUpperCase(methodNameArray[0]); String countMethodName = "count" + new String(methodNameArray); bodyBuilder.appendFormalLine( "float nrOfPages = (float) " + getShortName(formBackingType) + "." + countMethodName + "(" + methodParamsString + ") / sizeNo;"); bodyBuilder.appendFormalLine( "uiModel.addAttribute(\"maxPages\", (int) ((nrOfPages > (int) nrOfPages || nrOfPages == 0.0) ? nrOfPages + 1 : nrOfPages));"); bodyBuilder.indentRemove(); bodyBuilder.appendFormalLine("} else {"); bodyBuilder.indent(); bodyBuilder.appendFormalLine( "uiModel.addAttribute(\"" + javaTypeMetadataHolder.getPlural().toLowerCase() + "\", " + getShortName(formBackingType) + "." + finderMetadataDetails.getFinderMethodMetadata().getMethodName().getSymbolName() + "(" + methodParamsString + "sortFieldName, sortOrder).getResultList());"); bodyBuilder.indentRemove(); bodyBuilder.appendFormalLine("}"); if (dateFieldPresent) { bodyBuilder.appendFormalLine("addDateTimeFormatPatterns(uiModel);"); } bodyBuilder.appendFormalLine("return \"" + controllerPath + "/list\";"); final MethodMetadataBuilder methodBuilder = new MethodMetadataBuilder( getId(), Modifier.PUBLIC, finderMethodName, JavaType.STRING, parameterTypes, newParamNames, bodyBuilder); methodBuilder.setAnnotations(annotations); return methodBuilder; }