private Set<JavaSymbolName> populateFinders(
Set<JavaSymbolName> finders,
FieldMetadata field,
String prepend,
boolean isFirst,
String keyWord) {
Set<JavaSymbolName> tempFinders = new HashSet<JavaSymbolName>();
if (isTransient(field)) {
// No need to add transient fields
} else if (isFirst) {
String finderName =
prepend + field.getFieldName().getSymbolNameCapitalisedFirstLetter() + keyWord;
tempFinders.add(new JavaSymbolName(finderName));
} else {
for (JavaSymbolName finder : finders) {
String finderName = finder.getSymbolName();
if (!finderName.contains(field.getFieldName().getSymbolNameCapitalisedFirstLetter())) {
tempFinders.add(
new JavaSymbolName(
finderName
+ prepend
+ field.getFieldName().getSymbolNameCapitalisedFirstLetter()
+ keyWord));
}
}
}
return tempFinders;
}
private MethodMetadata getFindByStringIdMethod() {
if (!KEY.equals(identifierField.getFieldType())) {
return null;
}
final String idFieldName = identifierField.getFieldName().getSymbolName();
final JavaSymbolName methodName =
new JavaSymbolName("find" + destination.getSimpleTypeName() + "ByStringId");
final JavaType parameterType = STRING;
final List<JavaSymbolName> parameterNames = Arrays.asList(new JavaSymbolName(idFieldName));
final JavaType returnType = destination;
// Check if a method with the same signature already exists in the target type
final MethodMetadata method = getGovernorMethod(methodName, parameterType);
if (method != null) {
// If it already exists, just return the method and omit its generation via the ITD
return method;
}
final MethodMetadataBuilder methodBuilder =
new MethodMetadataBuilder(
getId(),
PUBLIC_ABSTRACT,
methodName,
returnType,
AnnotatedJavaType.convertFromJavaTypes(parameterType),
parameterNames,
BODY);
return methodBuilder.build();
}
public List<JavaSymbolName> getFinders(
MemberDetails memberDetails, String plural, int depth, Set<JavaSymbolName> exclusions) {
Assert.notNull(memberDetails, "Member details required");
Assert.hasText(plural, "Plural required");
Assert.notNull(
depth, "The depth of combinations used for finder signatures combinations required");
Assert.notNull(exclusions, "Exclusions required");
SortedSet<JavaSymbolName> finders = new TreeSet<JavaSymbolName>();
List<FieldMetadata> fields = memberDetails.getFields();
for (int i = 0; i < depth; i++) {
SortedSet<JavaSymbolName> tempFinders = new TreeSet<JavaSymbolName>();
for (FieldMetadata field : fields) {
// Ignoring java.util.Map field types (see ROO-194)
if (field == null || field.getFieldType().equals(new JavaType(Map.class.getName()))) {
continue;
}
if (exclusions.contains(field.getFieldName())) {
continue;
}
if (i == 0) {
tempFinders.addAll(createFinders(field, finders, "find" + plural + "By", true));
} else {
tempFinders.addAll(createFinders(field, finders, "And", false));
tempFinders.addAll(createFinders(field, finders, "Or", false));
}
}
finders.addAll(tempFinders);
}
return Collections.unmodifiableList(new ArrayList<JavaSymbolName>(finders));
}
private void doModification(final FieldMetadata field, final CustomData customData) {
MemberHoldingTypeDetails memberHoldingTypeDetails =
memberHoldingTypeDetailsMap.get(field.getDeclaredByMetadataId());
if (memberHoldingTypeDetails != null) {
FieldMetadata matchedField = memberHoldingTypeDetails.getField(field.getFieldName());
if (matchedField != null
&& !matchedField.getCustomData().keySet().containsAll(customData.keySet())) {
TypeDetailsBuilder typeDetailsBuilder = getTypeDetailsBuilder(memberHoldingTypeDetails);
typeDetailsBuilder.addDataToField(field, customData);
changed = true;
}
}
}
public void addDataToField(final FieldMetadata replacement, final CustomData customData) {
// If the MIDs don't match then the proposed can't be a replacement
if (!replacement.getDeclaredByMetadataId().equals(getDeclaredByMetadataId())) {
return;
}
for (FieldMetadataBuilder existingField : getDeclaredFields()) {
if (existingField.getFieldName().equals(replacement.getFieldName())) {
for (Object key : customData.keySet()) {
existingField.putCustomData(key, customData.get(key));
}
break;
}
}
}
/** @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();
}
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();
}
/**
* Method to obtain details of some entity
*
* @param out
*/
private void getEntityDetails(String entityName, PrintWriter out)
throws ServletException, IOException {
List<Entity> allEntities = new ArrayList<Entity>();
// Getting all entities
Set<ClassOrInterfaceTypeDetails> entities =
getTypeLocationService()
.findClassesOrInterfaceDetailsWithAnnotation(new JavaType(RooJavaBean.class));
Iterator<ClassOrInterfaceTypeDetails> it = entities.iterator();
while (it.hasNext()) {
// Getting entity
ClassOrInterfaceTypeDetails entity = it.next();
// Entity Name
String currentEntityName = entity.getName().getFullyQualifiedTypeName();
String topLevelPackage = getProjectOperations().getFocusedTopLevelPackage().toString();
// Replacing topLevelPackage with ~
currentEntityName = currentEntityName.replace(topLevelPackage, "~");
// Getting info only about selected entity
if (entityName.equals(currentEntityName)) {
List<Field> entityFields = new ArrayList<Field>();
for (FieldMetadata field : entity.getDeclaredFields()) {
// Getting fields values
String fieldName = field.getFieldName().getSymbolName();
String fieldType = field.getFieldType().getSimpleTypeName();
// Getting referenced class
String referencedClass = "";
if (field.getFieldType().getSimpleTypeName().equals("Set")
|| field.getFieldType().getSimpleTypeName().equals("List")) {
referencedClass = field.getFieldType().getParameters().get(0).getSimpleTypeName();
} else {
AnnotationMetadata manyToOneAnnotation =
field.getAnnotation(new JavaType("javax.persistence.ManyToOne"));
if (manyToOneAnnotation != null) {
referencedClass = field.getFieldType().getFullyQualifiedTypeName();
referencedClass = referencedClass.replace(topLevelPackage, "~");
fieldType = "Reference";
}
}
// Creating entityField Object
Field entityField = new Field(fieldName, fieldType, referencedClass);
// Adding field to entity
entityFields.add(entityField);
}
// Checking if current entity is abstract
boolean isAbstractEntity = entity.isAbstract();
// Adding extends type
List<String> extendsTypes = new ArrayList<String>();
for (JavaType extendsType : entity.getExtendsTypes()) {
extendsTypes.add(extendsType.getFullyQualifiedTypeName().replace(topLevelPackage, "~"));
}
// Creating Entity Object
allEntities.add(
new Entity(currentEntityName, extendsTypes, isAbstractEntity, entityFields));
}
}
// Returning JSON
ObjectWriter ow = new ObjectMapper().writer().withDefaultPrettyPrinter();
String json = ow.writeValueAsString(allEntities);
out.println(json);
}
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;
}
