public JavaSymbolName convertFromText(final String value, final Class<?> requiredType, final String optionContext) { if (StringUtils.isBlank(value)) { return null; } return new JavaSymbolName(value); }
private InvocableMemberBodyBuilder getSingularEntityAccessor(final FieldMetadata field, final JavaSymbolName hiddenIdFieldName) { final String entityName = field.getFieldName().getSymbolName(); final String entityIdName = hiddenIdFieldName.getSymbolName(); final String simpleFieldTypeName = field.getFieldType().getSimpleTypeName(); final String identifierMethodName = getIdentifierMethodName(field).getSymbolName(); final InvocableMemberBodyBuilder bodyBuilder = new InvocableMemberBodyBuilder(); bodyBuilder.appendFormalLine("if (this." + entityIdName + " != null) {"); bodyBuilder.indent(); bodyBuilder.appendFormalLine("if (this." + entityName + " == null || this." + entityName + "." + identifierMethodName + "() != this." + entityIdName + ") {"); bodyBuilder.indent(); bodyBuilder.appendFormalLine(THIS_DOT + entityName + " = " + simpleFieldTypeName + ".find" + simpleFieldTypeName + "(this." + entityIdName + ");"); bodyBuilder.indentRemove(); bodyBuilder.appendFormalLine("}"); bodyBuilder.indentRemove(); bodyBuilder.appendFormalLine("} else {"); bodyBuilder.indent(); bodyBuilder.appendFormalLine(THIS_DOT + entityName + " = null;"); bodyBuilder.indentRemove(); bodyBuilder.appendFormalLine("}"); bodyBuilder.appendFormalLine("return this." + entityName + ";"); return bodyBuilder; }
private boolean hasField(final List<? extends FieldMetadata> declaredFields, final FieldMetadata idField) { for (final FieldMetadata declaredField : declaredFields) { if (declaredField.getFieldName().equals(idField.getFieldName())) { return true; } } return false; }
/** * Generate method name to use for add method of selected field * * @param field * @return */ private JavaSymbolName getAddMethodName(final FieldMetadata field) { final JavaSymbolName methodName = new JavaSymbolName(ADD_METHOD_PREFIX + StringUtils.capitalize(field.getFieldName().getSymbolName())); return methodName; }
/** * Returns the mutator name for the given field name. * * @param fieldName the field name used to determine the accessor name * @return the mutator method name */ public static JavaSymbolName getMutatorMethodName(final JavaSymbolName fieldName) { Validate.notNull(fieldName, "Field name required"); return new JavaSymbolName("set" + StringUtils.capitalize(fieldName.getSymbolName())); }
/** * Returns the accessor name for the given field name and field type. * * @param fieldName the field name used to determine the accessor name * @param fieldType the field type * @return the accessor method name */ public static JavaSymbolName getAccessorMethodName(final JavaSymbolName fieldName, final JavaType fieldType) { Validate.notNull(fieldName, "Field name required"); Validate.notNull(fieldType, "Field type required"); final String capitalizedFieldName = StringUtils.capitalize(fieldName.getSymbolName()); return fieldType.equals(JavaType.BOOLEAN_PRIMITIVE) ? new JavaSymbolName("is" + capitalizedFieldName) : new JavaSymbolName("get" + capitalizedFieldName); }
/** * Gets the property of a related entity, using raw property information. * * @param rawProperty string that contains the definition of a property, which can be a property accessed by a relation. * @param referenceProperty property that represents a relation with other entity. * @return Pair that contains a property metadata and its name. */ private Pair<Stack<FieldMetadata>, String> extractRelatedEntityValidProperty( String extractProperty, FieldMetadata referenceProperty, Stack<FieldMetadata> path) { if (StringUtils.isBlank(extractProperty) || referenceProperty == null) { return null; } // Extract the property of a related entity String property = StringUtils.substringAfter(extractProperty, referenceProperty.getFieldName().toString()); if (StringUtils.isBlank(property)) { return null; } return extractValidProperty(property, getValidProperties(referenceProperty.getFieldType()), path); }
path = new Stack<FieldMetadata>(); if (StringUtils.isBlank(rawProperty) || fields == null) { return null; rawProperty = StringUtils.uncapitalize(rawProperty); if (field.getFieldName().toString().compareTo(rawProperty) == 0) { tempField = field; break; if (rawProperty.startsWith(field.getFieldName().toString())) { if (tempField == null || tempField.getFieldName().toString().length() < field.getFieldName().toString() .length()) tempField = field; return Pair.of( related.getLeft() == null ? path : related.getLeft(), StringUtils.capitalize(tempField.getFieldName().toString()).concat( StringUtils.capitalize(related.getRight()))); return Pair.of(path, StringUtils.capitalize(tempField.getFieldName().toString()));
if (methodName.toString().startsWith("findBy")) { methodName = new JavaSymbolName("find"); } else if (methodName.toString().startsWith("countBy")) { methodName = new JavaSymbolName("count"); methodName = new JavaSymbolName(methodName.toString().concat("By").concat(paramList)); new AnnotationMetadataBuilder(JavaType.WEB_PARAM); webParamAnnotation.addStringAttribute("name", paramName.toString()); webParamAnnotation.addStringAttribute("targetNamespace", ""); .getType().getPackage(), seiMethod.getMethodName().getSymbolNameCapitalisedFirstLetter())); .getSymbolNameCapitalisedFirstLetter())); .getType().getPackage(), seiMethod.getMethodName().getSymbolNameCapitalisedFirstLetter())); responseWrapperAnnotation.addStringAttribute("localName", String.format("%sResponse", seiMethod .getMethodName().getSymbolNameCapitalisedFirstLetter())); String.format("urn:%s", seiMethod.getMethodName().getSymbolNameCapitalisedFirstLetter())); new JavaSymbolName("Placement.DEFAULT")); NestedAnnotationAttributeValue newDocumentation1 = new NestedAnnotationAttributeValue(new JavaSymbolName("value"), new JavaSymbolName("Placement.PORT_TYPE_OPERATION_OUTPUT")); NestedAnnotationAttributeValue newDocumentation2 = new NestedAnnotationAttributeValue(new JavaSymbolName("value"),
options.add(StringUtils.removeEnd(subject, "Or").concat(ORDER_BY)); options.add(subject.concat(StringUtils.capitalize(field.getFieldName().toString()))); if (StringUtils.isNotBlank(type)) { options.add(subject.concat(type)); && lastAnd.getProperty().getKey().peek().getFieldType().equals(JavaType.STRING)) { options.add(subject.concat("IgnoreCase")); options.add(subject.concat("IgnoringCase")); List<FieldMetadata> fields = currentPartTreeInstance.getValidProperties(lastAnd.getProperty().getLeft().peek() .getFieldType()); options.add(subject.concat(StringUtils.capitalize(field.getFieldName().toString())));
/** * Gets method body expression for property-getter method * * @param prefix * @param propAccessorName * @param fieldName * @return */ private String getPropertyAccesorExpression(String prefix, JavaSymbolName propAccessorName, JavaSymbolName fieldName) { if (StringUtils.isBlank(prefix)) { return fieldName.toString(); } else { return String.format("%s.%s()", prefix, propAccessorName); } }
final JavaSymbolName methodName = new JavaSymbolName("update"); final String storedName = "stored".concat(this.entity.getSimpleTypeName()); parameterNames.add(new JavaSymbolName(storedName)); parameterNames.add(new JavaSymbolName(entityItemName)); parameterNames.add(new JavaSymbolName("result")); AnnotationMetadataBuilder putMappingAnnotation = new AnnotationMetadataBuilder(PUT_MAPPING); putMappingAnnotation.addStringAttribute("name", methodName.getSymbolName()); annotations.add(putMappingAnnotation); InvocableMemberBodyBuilder bodyBuilder = new InvocableMemberBodyBuilder(); bodyBuilder.appendFormalLine("%s.set%s(%s.get%s());", entityItemName, StringUtils.capitalize(entityIdentifier), storedName, StringUtils.capitalize(entityIdentifier)); JavaSymbolName relationField = item.getLeft().fieldMetadata.getFieldName(); JavaSymbolName relatedEntityIdentifier = item.getRight().getCurrentIndentifierField().getFieldName(); bodyBuilder.appendFormalLine("%1$s.get%2$s().set%3$s(%4$s.get%2$s().get%3$s());", entityItemName, relationField.getSymbolNameCapitalisedFirstLetter(), relatedEntityIdentifier.getSymbolNameCapitalisedFirstLetter(), storedName); return methodBuilder.build();
final JavaSymbolName methodName = new JavaSymbolName("show"); parameterTypes.add(new AnnotatedJavaType(entity, ANN_MODEL_ATTRIBUTE)); parameterNames.add(new JavaSymbolName(entityItemName)); AnnotatedJavaType.convertFromAnnotatedJavaTypes(parameterTypes)); if (existingMethod != null) { return existingMethod; AnnotationMetadataBuilder getMappingAnnotation = new AnnotationMetadataBuilder(GET_MAPPING); getMappingAnnotation.addStringAttribute("name", methodName.getSymbolName()); annotations.add(getMappingAnnotation); InvocableMemberBodyBuilder bodyBuilder = new InvocableMemberBodyBuilder(); bodyBuilder.appendFormalLine("return %s.ok(%s);", getNameOfJavaType(RESPONSE_ENTITY), entityItemName); new MethodMetadataBuilder(getId(), Modifier.PUBLIC, methodName, JavaType.wrapperWilcard(RESPONSE_ENTITY), parameterTypes, parameterNames, bodyBuilder); methodBuilder.setAnnotations(annotations); return methodBuilder.build();
new JavaType(String.format("%s.%s", getPackageNameFromTargetNameSpace(targetNameSpace), StringUtils.capitalize(endPoint.getName()))); JavaSymbolName methodName = new JavaSymbolName(StringUtils.uncapitalize(endPoint.getName())); InvocableMemberBodyBuilder bodyBuilder = new InvocableMemberBodyBuilder(); bodyBuilder.appendFormalLine("%s jaxWsFactory = new JaxWsProxyFactoryBean();", getNameOfJavaType(new JavaType("org.apache.cxf.jaxws.JaxWsProxyFactoryBean"))); bodyBuilder.appendFormalLine("jaxWsFactory.setServiceClass(%s.class);", getNameOfJavaType(endPointType)); if (endPoint.getBindingType().getField().getSymbolName().equals(SoapBindingType.SOAP12.name())) { bodyBuilder.appendFormalLine("jaxWsFactory.setBindingId(%s.SOAP12HTTP_BINDING);", getNameOfJavaType(new JavaType("javax.xml.ws.soap.SOAPBinding"))); "%s.info(\"Web Service client %s has been created. URL: '{}'\", this.%s);", getLoggerField().getFieldName(), getEndPointField(endPoint).getFieldName() .getSymbolNameCapitalisedFirstLetter(), getEndPointField(endPoint).getFieldName()); new MethodMetadataBuilder(getId(), Modifier.PUBLIC, methodName, endPointType, bodyBuilder); method.addAnnotation(new AnnotationMetadataBuilder(SpringJavaType.BEAN));
final Map<String, String> properties = new LinkedHashMap<String, String>(); final String entityName = entity.getSimpleTypeName(); properties.put(buildLabel(entityName), new JavaSymbolName(entity.getSimpleTypeName() .toLowerCase()).getReadableSymbolName()); final String pluralResourceId = buildLabel(entity.getSimpleTypeName(), "plural"); final String plural = getPluralService().getPlural(entity); properties.put(pluralResourceId, new JavaSymbolName(plural).getReadableSymbolName()); properties.put(buildLabel(entityName, idField.getFieldName().getSymbolName()), idField .getFieldName().getReadableSymbolName()); final String fieldResourceId = buildLabel(entityName, field.getFieldName().getSymbolName()); properties.put(fieldResourceId, field.getFieldName().getReadableSymbolName()); String enumLabelCode = XmlUtils.convertId("enum.".concat(fieldType.getSimpleTypeName()).concat(".") .concat(constant.getSymbolName())); String enumLabelValue = StringUtils.capitalize(constant.getSymbolName().toLowerCase()); properties.put(enumLabelCode, enumLabelValue); buildLabel(entityName, field.getFieldName().getSymbolName(), referencedEntityField .getFieldName().getSymbolName()); properties.put(referenceEntityFieldResourceId, referencedEntityField.getFieldName() .getReadableSymbolName());
/** * Builds and returns a method used to instance a DataOnDemand class using * {@link EntityManager} and `@Bean` annotation. * * @param dodType * the class to inject in the Spring context. * @return the MethodMetadata to add to ITD. */ private MethodMetadata getDodTypeBeanCreationMethod(JavaType dodType) { // Define methodName final JavaSymbolName methodName = new JavaSymbolName(StringUtils.uncapitalize(dodType.getSimpleTypeName())); // Check if method exists MethodMetadata existingMethod = getGovernorMethod(methodName); if (existingMethod != null) { return existingMethod; } // Add body InvocableMemberBodyBuilder bodyBuilder = new InvocableMemberBodyBuilder(); bodyBuilder.appendFormalLine("return new %s(%s());", getNameOfJavaType(dodType), getAccessorMethod(getEntityManagerField().build()).getMethodName()); // Create method MethodMetadataBuilder method = new MethodMetadataBuilder(this.getId(), Modifier.PUBLIC, methodName, dodType, bodyBuilder); // Add annotation method.addAnnotation(new AnnotationMetadataBuilder(SpringJavaType.BEAN)); return method.build(); }
/** * Construct a Java symbol name which adheres to the strict JavaBean naming * conventions and avoids use of {@link ReservedWords} by suffixing '_' * * @param javaType the {@link JavaType} for which the symbol name is created * @return a Java symbol name adhering to JavaBean conventions and avoids * reserved words * @since 1.2.0 */ public static JavaSymbolName getReservedWordSafeName(final JavaType javaType) { final String simpleTypeName = javaType.getSimpleTypeName(); String str = Introspector.decapitalize(StringUtils.capitalize(simpleTypeName)); while (ReservedWords.RESERVED_JAVA_KEYWORDS.contains(str)) { // Prefixing can create names that don't work in the Derby DB str += "_"; } if (str.equals(simpleTypeName)) { // ROO-2929 str += "_"; } return new JavaSymbolName(str); }
new JavaSymbolName("init" + entity.getSimpleTypeName() + "Binder"); parameterTypes.add(AnnotatedJavaType.convertFromJavaType(SpringJavaType.WEB_DATA_BINDER)); List<JavaSymbolName> parameterNames = new ArrayList<JavaSymbolName>(); parameterNames.add(new JavaSymbolName("binder")); AnnotatedJavaType.convertFromAnnotatedJavaTypes(parameterTypes)); if (existingMethod != null) { return existingMethod; InvocableMemberBodyBuilder body = new InvocableMemberBodyBuilder(); body.appendFormalLine("binder.setDisallowedFields(\"%s\");", entityIdentifier); body.appendFormalLine("binder.setDisallowedFields(\"%s.%s\");", item.getKey().fieldName, item .getValue().getCurrentIndentifierField().getFieldName()); new MethodMetadataBuilder(getId(), Modifier.PUBLIC, methodName, JavaType.VOID_PRIMITIVE, parameterTypes, parameterNames, body); AnnotationMetadataBuilder getInitBinderAnnotation = new AnnotationMetadataBuilder(INIT_BINDER); getInitBinderAnnotation.addStringAttribute("value", StringUtils.uncapitalize(entity.getSimpleTypeName())); annotations.add(getInitBinderAnnotation); methodBuilder.setAnnotations(annotations); return methodBuilder.build();
new JavaSymbolName("set" + relationInfo.fieldMetadata.getFieldName().getSymbolNameCapitalisedFirstLetter()); parameterTypes.add(AnnotatedJavaType.convertFromJavaType(entity)); parameterNames.add(new JavaSymbolName(StringUtils.uncapitalize(entity.getSimpleTypeName()))); parameterNames.add(relationInfo.fieldMetadata.getFieldName()); if (relationInfo.cardinality == Cardinality.ONE_TO_ONE) { parameterTypes.add(AnnotatedJavaType.convertFromJavaType(relationInfo.childType)); } else if (relationInfo.type == JpaRelationType.COMPOSITION) { parameterTypes.add(AnnotatedJavaType.convertFromJavaType(JavaType .iterableOf(relationInfo.childType))); } else { aspectName); parameterTypes.add(AnnotatedJavaType.convertFromJavaType(JavaType .iterableOf(childEntityMetadata.getCurrentIndentifierField().getFieldType()))); new MethodMetadataBuilder(getId(), Modifier.PUBLIC + Modifier.ABSTRACT, methodName, entity, parameterTypes, parameterNames, null); return methodBuilder.build(); // Build and return a MethodMetadata
options.add(query.concat(StringUtils.capitalize(field.getFieldName().toString()))); .getFieldType()); options.add(query.concat(StringUtils.capitalize(field.getFieldName().toString())));