private MethodMetadataBuilder getCreateMethod(String declaredById, JavaType targetType) {
InvocableMemberBodyBuilder invocableMemberBodyBuilder =
InvocableMemberBodyBuilder.getInstance();
invocableMemberBodyBuilder.append("return new " + targetType.getSimpleTypeName() + "();");
MethodMetadataBuilder createMethodBuilder =
new MethodMetadataBuilder(
declaredById,
Modifier.PUBLIC,
new JavaSymbolName("create"),
targetType,
invocableMemberBodyBuilder);
JavaType wildEntityType =
new JavaType(
targetType.getFullyQualifiedTypeName(),
0,
DataType.VARIABLE,
JavaType.WILDCARD_EXTENDS,
null);
JavaType classParameterType =
new JavaType(
JavaType.CLASS.getFullyQualifiedTypeName(),
0,
DataType.TYPE,
null,
Arrays.asList(wildEntityType));
createMethodBuilder.addParameter("clazz", classParameterType);
return createMethodBuilder;
}
/** @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 (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;
}
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 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;
}
private MethodMetadataBuilder getFindMethod(
ClassOrInterfaceTypeDetailsBuilder locatorBuilder,
String declaredById,
JavaType targetType,
JavaType idType) {
MemberTypeAdditions findMethodAdditions =
layerService.getMemberTypeAdditions(
declaredById,
PersistenceCustomDataKeys.FIND_METHOD.name(),
targetType,
idType,
LAYER_POSITION,
new MethodParameter(idType, "id"));
InvocableMemberBodyBuilder invocableMemberBodyBuilder =
InvocableMemberBodyBuilder.getInstance();
invocableMemberBodyBuilder
.append("return ")
.append(findMethodAdditions.getMethodCall())
.append(";");
findMethodAdditions.copyAdditionsTo(locatorBuilder, locatorBuilder.build());
MethodMetadataBuilder findMethodBuilder =
new MethodMetadataBuilder(
declaredById,
Modifier.PUBLIC,
new JavaSymbolName("find"),
targetType,
invocableMemberBodyBuilder);
JavaType wildEntityType =
new JavaType(
targetType.getFullyQualifiedTypeName(),
0,
DataType.VARIABLE,
JavaType.WILDCARD_EXTENDS,
null);
JavaType classParameterType =
new JavaType(
JavaType.CLASS.getFullyQualifiedTypeName(),
0,
DataType.TYPE,
null,
Arrays.asList(wildEntityType));
findMethodBuilder.addParameter("clazz", classParameterType);
findMethodBuilder.addParameter("id", idType);
return findMethodBuilder;
}
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 MethodMetadataBuilder getDomainTypeMethod(String declaredById, JavaType targetType) {
InvocableMemberBodyBuilder invocableMemberBodyBuilder =
InvocableMemberBodyBuilder.getInstance();
invocableMemberBodyBuilder.append("return " + targetType.getSimpleTypeName() + ".class;");
JavaType returnType =
new JavaType(
JavaType.CLASS.getFullyQualifiedTypeName(),
0,
DataType.TYPE,
null,
Arrays.asList(targetType));
return new MethodMetadataBuilder(
declaredById,
Modifier.PUBLIC,
new JavaSymbolName("getDomainType"),
returnType,
invocableMemberBodyBuilder);
}
private MethodMetadataBuilder getIdMethod(
String declaredById, JavaType targetType, MethodMetadata idAccessor) {
InvocableMemberBodyBuilder invocableMemberBodyBuilder =
InvocableMemberBodyBuilder.getInstance();
invocableMemberBodyBuilder.append(
"return "
+ StringUtils.uncapitalize(targetType.getSimpleTypeName())
+ "."
+ idAccessor.getMethodName()
+ "();");
MethodMetadataBuilder getIdMethod =
new MethodMetadataBuilder(
declaredById,
Modifier.PUBLIC,
new JavaSymbolName("getId"),
GwtUtils.convertPrimitiveType(idAccessor.getReturnType(), true),
invocableMemberBodyBuilder);
getIdMethod.addParameter(StringUtils.uncapitalize(targetType.getSimpleTypeName()), targetType);
return getIdMethod;
}
private MethodMetadataBuilder getVersionMethod(
String declaredById, JavaType targetType, MethodMetadata versionAccessor) {
InvocableMemberBodyBuilder invocableMemberBodyBuilder =
InvocableMemberBodyBuilder.getInstance();
invocableMemberBodyBuilder.append(
"return "
+ StringUtils.uncapitalize(targetType.getSimpleTypeName())
+ "."
+ versionAccessor.getMethodName()
+ "();");
MethodMetadataBuilder getIdMethodBuilder =
new MethodMetadataBuilder(
declaredById,
Modifier.PUBLIC,
new JavaSymbolName("getVersion"),
JavaType.OBJECT,
invocableMemberBodyBuilder);
getIdMethodBuilder.addParameter(
StringUtils.uncapitalize(targetType.getSimpleTypeName()), targetType);
return getIdMethodBuilder;
}
/** @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 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();
}
/** @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 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();
}
/** @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;
}
/** @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 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;
}
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();
}
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;
}
/**
* 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();
}
/** @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();
}
/**
* 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 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();
}