/**
* Locates the entity manager field that should be used.
*
* <p>If a parent is defined, it must provide the field.
*
* <p>We generally expect the field to be named "entityManager" and be of type
* javax.persistence.EntityManager. We also require it to be public or protected, and annotated
* with @PersistenceContext. If there is an existing field which doesn't meet these latter
* requirements, we add an underscore prefix to the "entityManager" name and try again, until such
* time as we come up with a unique name that either meets the requirements or the name is not
* used and we will create it.
*
* @return the entity manager field (never returns null)
*/
public FieldMetadata getEntityManagerField() {
if (parent != null) {
// The parent is required to guarantee this is available
return parent.getEntityManagerField();
}
// Need to locate it ourself
int index = -1;
while (true) {
// Compute the required field name
index++;
final JavaSymbolName fieldSymbolName =
new JavaSymbolName(StringUtils.repeat("_", index) + "entityManager");
final FieldMetadata candidate = governorTypeDetails.getField(fieldSymbolName);
if (candidate != null) {
// Verify if candidate is suitable
if (!Modifier.isPublic(candidate.getModifier())
&& !Modifier.isProtected(candidate.getModifier())
&& (Modifier.TRANSIENT != candidate.getModifier())) {
// Candidate is not public and not protected and not simply a transient field (in which
// case subclasses
// will see the inherited field), so any subsequent subclasses won't be able to see it.
// Give up!
continue;
}
if (!candidate.getFieldType().equals(ENTITY_MANAGER)) {
// Candidate isn't an EntityManager, so give up
continue;
}
if (MemberFindingUtils.getAnnotationOfType(candidate.getAnnotations(), PERSISTENCE_CONTEXT)
== null) {
// Candidate doesn't have a PersistenceContext annotation, so give up
continue;
}
// If we got this far, we found a valid candidate
return candidate;
}
// Candidate not found, so let's create one
final List<AnnotationMetadataBuilder> annotations =
new ArrayList<AnnotationMetadataBuilder>();
final AnnotationMetadataBuilder annotationBuilder =
new AnnotationMetadataBuilder(PERSISTENCE_CONTEXT);
if (StringUtils.hasText(crudAnnotationValues.getPersistenceUnit())) {
annotationBuilder.addStringAttribute("unitName", crudAnnotationValues.getPersistenceUnit());
}
annotations.add(annotationBuilder);
final FieldMetadataBuilder fieldBuilder =
new FieldMetadataBuilder(
getId(), Modifier.TRANSIENT, annotations, fieldSymbolName, ENTITY_MANAGER);
return fieldBuilder.build();
}
}
public void addField(final FieldMetadata field) {
Assert.notNull(field, "Field metadata not provided");
// Obtain the physical type and ITD mutable details
PhysicalTypeMetadata ptm =
(PhysicalTypeMetadata) metadataService.get(field.getDeclaredByMetadataId());
Assert.notNull(
ptm,
"Java source code unavailable for type "
+ PhysicalTypeIdentifier.getFriendlyName(field.getDeclaredByMetadataId()));
PhysicalTypeDetails ptd = ptm.getMemberHoldingTypeDetails();
Assert.notNull(
ptd,
"Java source code details unavailable for type "
+ PhysicalTypeIdentifier.getFriendlyName(field.getDeclaredByMetadataId()));
ClassOrInterfaceTypeDetailsBuilder cidBuilder =
new ClassOrInterfaceTypeDetailsBuilder((ClassOrInterfaceTypeDetails) ptd);
// Automatically add JSR 303 (Bean Validation API) support if there is
// no current JSR 303 support but a JSR 303 annotation is present
boolean jsr303Required = false;
for (AnnotationMetadata annotation : field.getAnnotations()) {
if (annotation
.getAnnotationType()
.getFullyQualifiedTypeName()
.startsWith("javax.validation")) {
jsr303Required = true;
break;
}
}
LogicalPath path = PhysicalTypeIdentifier.getPath(cidBuilder.getDeclaredByMetadataId());
if (jsr303Required) {
// It's more likely the version below represents a later version
// than any specified in the user's own dependency list
projectOperations.addDependency(
path.getModule(), "javax.validation", "validation-api", "1.0.0.GA");
}
cidBuilder.addField(field);
createOrUpdateTypeOnDisk(cidBuilder.build());
}
/** Adds the JUnit and Spring type level annotations if needed */
private void addRequiredIntegrationTestClassIntroductions(final JavaType dodGovernor) {
// Add an @RunWith(SpringJunit4ClassRunner) annotation to the type, if
// the user did not define it on the governor directly
if (MemberFindingUtils.getAnnotationOfType(governorTypeDetails.getAnnotations(), RUN_WITH)
== null) {
AnnotationMetadataBuilder runWithBuilder = new AnnotationMetadataBuilder(RUN_WITH);
runWithBuilder.addClassAttribute(
"value", "org.springframework.test.context.junit4.SpringJUnit4ClassRunner");
builder.addAnnotation(runWithBuilder);
}
// Add an @ContextConfiguration("classpath:/applicationContext.xml")
// annotation to the type, if the user did not define it on the governor
// directly
if (MemberFindingUtils.getAnnotationOfType(
governorTypeDetails.getAnnotations(), CONTEXT_CONFIGURATION)
== null) {
AnnotationMetadataBuilder contextConfigurationBuilder =
new AnnotationMetadataBuilder(CONTEXT_CONFIGURATION);
contextConfigurationBuilder.addStringAttribute(
"locations", "classpath:/META-INF/spring/applicationContext*.xml");
builder.addAnnotation(contextConfigurationBuilder);
}
// Add an @Transactional, if the user did not define it on the governor
// directly
if (annotationValues.isTransactional()
&& MemberFindingUtils.getAnnotationOfType(
governorTypeDetails.getAnnotations(), TRANSACTIONAL)
== null) {
AnnotationMetadataBuilder transactionalBuilder = new AnnotationMetadataBuilder(TRANSACTIONAL);
if (StringUtils.hasText(transactionManager)
&& !"transactionManager".equals(transactionManager)) {
transactionalBuilder.addStringAttribute("value", transactionManager);
}
builder.addAnnotation(transactionalBuilder);
}
// Add the data on demand field if the user did not define it on the
// governor directly
FieldMetadata field = governorTypeDetails.getField(new JavaSymbolName("dod"));
if (field != null) {
Assert.isTrue(
field.getFieldType().equals(dodGovernor),
"Field 'dod' on '"
+ destination.getFullyQualifiedTypeName()
+ "' must be of type '"
+ dodGovernor.getFullyQualifiedTypeName()
+ "'");
Assert.notNull(
MemberFindingUtils.getAnnotationOfType(field.getAnnotations(), AUTOWIRED),
"Field 'dod' on '"
+ destination.getFullyQualifiedTypeName()
+ "' must be annotated with @Autowired");
} else {
// Add the field via the ITD
List<AnnotationMetadataBuilder> annotations = new ArrayList<AnnotationMetadataBuilder>();
annotations.add(new AnnotationMetadataBuilder(AUTOWIRED));
FieldMetadataBuilder fieldBuilder =
new FieldMetadataBuilder(
getId(), Modifier.PRIVATE, annotations, new JavaSymbolName("dod"), dodGovernor);
builder.addField(fieldBuilder);
}
builder.getImportRegistrationResolver().addImport(ASSERT);
}
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;
}
