/** * Generates the Springlets `@EntityFormat` annotation to be applied to the projection * * @return AnnotationMetadata */ private AnnotationMetadata getEntityFormatAnnotation() { String expressionAttribute = this.annotationValues.getFormatExpression(); String messageAttribute = this.annotationValues.getFormatMessage(); final AnnotationMetadataBuilder entityFormatBuilder = new AnnotationMetadataBuilder(SpringletsJavaType.SPRINGLETS_ENTITY_FORMAT); // Check for each attribute individually if (StringUtils.isNotBlank(expressionAttribute)) { entityFormatBuilder.addStringAttribute("value", expressionAttribute); } if (StringUtils.isNotBlank(messageAttribute)) { entityFormatBuilder.addStringAttribute("message", messageAttribute); } return entityFormatBuilder.build(); }
/** * Adds an attribute with the given {@link JavaType} as its value * * @param key the attribute name (required) * @param javaType the value (required) */ public void addClassAttribute(final String key, final JavaType javaType) { addAttribute(new ClassAttributeValue(new JavaSymbolName(key), javaType)); }
final String formatExpression, final String formatMessage) { final AnnotationMetadataBuilder entityAnnotationBuilder = new AnnotationMetadataBuilder(ROO_JPA_ENTITY); entityAnnotationBuilder.addStringAttribute("catalog", catalog); entityAnnotationBuilder.addStringAttribute("entityName", entityName); entityAnnotationBuilder.addStringAttribute("inheritanceType", inheritanceType.name()); entityAnnotationBuilder.addBooleanAttribute("mappedSuperclass", mappedSuperclass); entityAnnotationBuilder.addStringAttribute("schema", schema); entityAnnotationBuilder.addStringAttribute("table", table); if (StringUtils.isNotBlank(formatExpression)) { entityAnnotationBuilder.addStringAttribute("entityFormatExpression", formatExpression); if (StringUtils.isNotBlank(formatMessage)) { entityAnnotationBuilder.addStringAttribute("entityFormatMessage", formatMessage); entityAnnotationBuilder.addBooleanAttribute("readOnly", true);
/** * Builds and returns @SpringletsWebMvcTest annotation * * @return {@link AnnotationMetadataBuilder} */ private AnnotationMetadataBuilder getSpringletsWebMvcAnnotation() { AnnotationMetadataBuilder annotationBuilder = new AnnotationMetadataBuilder(SpringletsJavaType.SPRINGLETS_WEB_MVC_TEST); annotationBuilder.addClassAttribute("controllers", this.controller); annotationBuilder.addBooleanAttribute("secure", false); return annotationBuilder; }
/** * Builds @EntityListeners annotation * * @return AnnotationMetadataBuilder with the prepared annotation */ private AnnotationMetadataBuilder getEntityListenersAnnotation() { AnnotationMetadataBuilder annotation = new AnnotationMetadataBuilder(JpaJavaType.ENTITY_LISTENERS); annotation.addClassAttribute("value", SpringJavaType.AUDITING_ENTITY_LISTENER); return annotation; }
/** * Returns the metadata for the existing annotation, with no attribute * values * * @param annotationType the annotation type (required) * @return a non-<code>null</code> instance * @since 1.2.0 */ public static AnnotationMetadata getInstance(final Class<?> annotationType) { return new AnnotationMetadataBuilder(annotationType).build(); }
projectOperations.setModule(projectOperations.getPomFromModuleName(name.getModule())); fieldsToAdd.put(field.getFieldName().getSymbolName(), field); new AnnotationMetadataBuilder(RooJavaType.ROO_JAVA_BEAN); rooJavaBeanAnnotation.addBooleanAttribute("settersByDefault", false); projectionBuilder.addAnnotation(rooJavaBeanAnnotation); AnnotationMetadataBuilder rooToStringAnnotation = new AnnotationMetadataBuilder(RooJavaType.ROO_TO_STRING); AnnotationMetadataBuilder rooEqualsAnnotation = new AnnotationMetadataBuilder(RooJavaType.ROO_EQUALS); projectionBuilder.addAnnotation(rooToStringAnnotation); projectionBuilder.addAnnotation(rooEqualsAnnotation); new AnnotationMetadataBuilder(RooJavaType.ROO_ENTITY_PROJECTION); projectionAnnotation.addClassAttribute("entity", entity); List<StringAttributeValue> fieldNames = new ArrayList<StringAttributeValue>(); projectionAnnotation.addAttribute(new ArrayAttributeValue<StringAttributeValue>( new JavaSymbolName("fields"), fieldNames)); if (StringUtils.isNotBlank(formatExpression)) { projectionAnnotation.addStringAttribute("formatExpression", formatExpression); if (StringUtils.isNotBlank(formatMessage)) { projectionAnnotation.addStringAttribute("formatMessage", formatMessage);
if (StringUtils.isNotBlank(columnName)) { AnnotationMetadataBuilder columnAnnotation = new AnnotationMetadataBuilder(JpaJavaType.COLUMN); columnAnnotation.addStringAttribute("name", columnName); annotations.add(columnAnnotation); new AnnotationMetadataBuilder(SpringJavaType.CREATED_DATE); annotations.add(createdDateAnnotation); new AnnotationMetadataBuilder(JpaJavaType.TEMPORAL); temporalAnnotation.addEnumAttribute("value", new EnumDetails(JpaJavaType.TEMPORAL_TYPE, new JavaSymbolName("TIMESTAMP"))); annotations.add(temporalAnnotation); new AnnotationMetadataBuilder(SpringJavaType.DATE_TIME_FORMAT); dateTimeFormatAnnotation.addStringAttribute("style", "M-"); annotations.add(dateTimeFormatAnnotation); JdkJavaType.CALENDAR, new JavaSymbolName("createdDate")); fieldDetails.setModifiers(Modifier.PRIVATE); fieldDetails.setAnnotations(annotations);
private AnnotationMetadataBuilder buildEntityFormatAnnotation( final String entityFormatExpression, final String entityFormatMessage, final String fieldName) { final AnnotationMetadataBuilder entityFormatBuilder = new AnnotationMetadataBuilder(SpringletsJavaType.SPRINGLETS_ENTITY_FORMAT); // Check for each attribute individually if (StringUtils.isNotBlank(entityFormatExpression)) { entityFormatBuilder.addStringAttribute("value", entityFormatExpression); } if (StringUtils.isNotBlank(entityFormatMessage)) { entityFormatBuilder.addStringAttribute("message", entityFormatMessage); } return entityFormatBuilder; }
/** * Returns the JPA @Inheritance annotation to be applied to the entity, if * applicable * * @param annotationValues the values of the {@link RooJpaEntity} annotation * (required) * @return <code>null</code> if it's already present or not required */ private AnnotationMetadata getInheritanceAnnotation() { if (governorTypeDetails.getAnnotation(INHERITANCE) != null) { return null; } if (StringUtils.isNotBlank(annotationValues.getInheritanceType())) { final AnnotationMetadataBuilder inheritanceBuilder = new AnnotationMetadataBuilder(INHERITANCE); inheritanceBuilder.addEnumAttribute("strategy", new EnumDetails(INHERITANCE_TYPE, new JavaSymbolName(annotationValues.getInheritanceType()))); return inheritanceBuilder.build(); } return null; }
ClassOrInterfaceTypeDetailsBuilder controllerBuilder; JavaType searchController = new JavaType(String.format("%s.%sSearch%sController", controllerPackage.getFullyQualifiedPackageName(), pluralService.getPlural(entity), responseType.getControllerNameModifier()), controllerPackage.getModule()); new AnnotationMetadataBuilder(RooJavaType.ROO_CONTROLLER); controllerAnnotation.addClassAttribute("entity", entity); if (StringUtils.isNotBlank(pathPrefix)) { controllerAnnotation.addStringAttribute("pathPrefix", pathPrefix); controllerAnnotation.addEnumAttribute("type", new EnumDetails( RooJavaType.ROO_ENUM_CONTROLLER_TYPE, new JavaSymbolName("SEARCH"))); controllerBuilder.addAnnotation(controllerAnnotation.build()); new AnnotationMetadataBuilder(RooJavaType.ROO_SEARCH); List<AnnotationAttributeValue<?>> findersToAdd = new ArrayList<AnnotationAttributeValue<?>>(); for (String finder : queryMethods) { findersToAdd.add(new StringAttributeValue(new JavaSymbolName("value"), finder)); searchAnnotation.addAttribute(new ArrayAttributeValue<AnnotationAttributeValue<?>>( new JavaSymbolName("finders"), findersToAdd)); controllerBuilder.addAnnotation(searchAnnotation); new AnnotationMetadataBuilder(responseType.getAnnotation()); controllerBuilder.addAnnotation(responseTypeAnnotation); return controllerBuilder;
private AnnotationMetadataBuilder getColumnBuilder(final Identifier identifier) { final AnnotationMetadataBuilder columnBuilder = new AnnotationMetadataBuilder(COLUMN); columnBuilder.addStringAttribute("name", identifier.getColumnName()); if (StringUtils.isNotBlank(identifier.getColumnDefinition())) { columnBuilder.addStringAttribute("columnDefinition", identifier.getColumnDefinition()); } columnBuilder.addBooleanAttribute("nullable", false); // Add length attribute for Strings if (identifier.getColumnSize() < 4000 && identifier.getFieldType().equals(JavaType.STRING)) { columnBuilder.addIntegerAttribute("length", identifier.getColumnSize()); } // Add precision and scale attributes for numeric fields if (identifier.getScale() > 0 && (identifier.getFieldType().equals(JavaType.DOUBLE_OBJECT) || identifier.getFieldType().equals(JavaType.DOUBLE_PRIMITIVE) || identifier .getFieldType().equals(BIG_DECIMAL))) { columnBuilder.addIntegerAttribute("precision", identifier.getColumnSize()); columnBuilder.addIntegerAttribute("scale", identifier.getScale()); } return columnBuilder; }
boolean serializable, String formatExpression, String formatMessage) { Validate.isTrue(!JdkJavaType.isPartOfJavaLang(name.getSimpleTypeName()), "Class name '%s' is part of java.lang", name.getSimpleTypeName()); projectOperations.setModule(projectOperations.getPomFromModuleName(name.getModule())); AnnotationMetadataBuilder rooDtoAnnotation = new AnnotationMetadataBuilder(RooJavaType.ROO_DTO); AnnotationMetadataBuilder rooJavaBeanAnnotation = new AnnotationMetadataBuilder(RooJavaType.ROO_JAVA_BEAN); if (immutable) { rooDtoAnnotation.addBooleanAttribute("immutable", immutable); rooJavaBeanAnnotation.addBooleanAttribute("settersByDefault", false); if (StringUtils.isNotBlank(formatExpression)) { rooDtoAnnotation.addStringAttribute("formatExpression", formatExpression); if (StringUtils.isNotBlank(formatMessage)) { rooDtoAnnotation.addStringAttribute("formatMessage", formatMessage); new AnnotationMetadataBuilder(RooJavaType.ROO_TO_STRING); AnnotationMetadataBuilder rooEqualsAnnotation = new AnnotationMetadataBuilder(RooJavaType.ROO_EQUALS); cidBuilder.addAnnotation(rooToStringAnnotation); cidBuilder.addAnnotation(rooEqualsAnnotation); new AnnotationMetadataBuilder(RooJavaType.ROO_SERIALIZABLE); cidBuilder.addAnnotation(rooSerializableAnnotation);
new AnnotationMetadataBuilder(REQUEST_PARAM); requestParamIdsAnnotation.addStringAttribute("value", "ids"); parameterTypes .add(new AnnotatedJavaType(JavaType.wrapperOf(JavaType.LIST, findAllByIdsInMethod .getParameterTypes().get(0).getJavaType().getBaseType()), requestParamIdsAnnotation .build())); parameterTypes.add(DATATABLES_COLUMNS_PARAM); parameterTypes.add(GLOBAL_SEARCH_PARAM); parameterTypes.add(DATATABLES_PAGEABLE_PARAM); AnnotationMetadataBuilder requestParamAnnotation = new AnnotationMetadataBuilder(REQUEST_PARAM); requestParamAnnotation.addStringAttribute("value", "draw"); parameterTypes.add(new AnnotatedJavaType(JavaType.INT_OBJECT, requestParamAnnotation.build())); AnnotationMetadataBuilder getMappingAnnotation = new AnnotationMetadataBuilder(GET_MAPPING); getMappingAnnotation.addStringAttribute("name", methodName.getSymbolName()); getMappingAnnotation.addEnumAttribute("produces", SPRINGLETS_DATATABLES, "MEDIA_TYPE"); getMappingAnnotation.addStringAttribute("value", "/dtByIdsIn"); JavaType.wrapperOf(SpringletsJavaType.SPRINGLETS_CONVERTED_DATATABLES_DATA, final InvocableMemberBodyBuilder bodyBuilder = new InvocableMemberBodyBuilder(); final String itemsName = StringUtils.uncapitalize(detailsInfo.fieldName); final String totalVarName = "total" + StringUtils.capitalize(itemsName) + "Count"; 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 JavaSymbolName("get" + StringUtils.capitalize(pathVariable)); serviceMetadata.getCurrentFindOneMethod().getParameterTypes().get(0).getJavaType(); final JavaSymbolName idName = serviceMetadata.getCurrentFindOneMethod().getParameterNames().get(0); new AnnotationMetadataBuilder(SpringJavaType.PATH_VARIABLE); pathVariableAnnotation.addStringAttribute("value", StringUtils.uncapitalize(pathVariable)); parameterTypes.add(new AnnotatedJavaType(idType, pathVariableAnnotation.build())); AnnotatedJavaType.convertFromAnnotatedJavaTypes(parameterTypes)); if (existingMethod != null) { return existingMethod; InvocableMemberBodyBuilder bodyBuilder = new InvocableMemberBodyBuilder(); bodyBuilder.appendFormalLine("%s %s = %s.%s(%s);", getNameOfJavaType(entityType), pathVariable, serviceField.getFieldName(), serviceMetadata.getCurrentFindOneMethod().getMethodName(), idName); new MethodMetadataBuilder(getId(), Modifier.PUBLIC, methodName, entityType, parameterTypes, parameterNames, bodyBuilder); methodBuilder.addAnnotation(ANN_MODEL_ATTRIBUTE); return methodBuilder.build();
new AnnotationMetadataBuilder(REQUEST_PARAM); requestParamAnnotation.addStringAttribute("value", VERSION_PARAM_NAME.getSymbolName()); parameterTypes.add(new AnnotatedJavaType(this.entityMetadata.getCurrentVersionField() .getFieldType(), requestParamAnnotation.build())); new AnnotationMetadataBuilder(REQUEST_PARAM); concurrencyControlRequestParam.addStringAttribute("value", "concurrency"); concurrencyControlRequestParam.addBooleanAttribute("required", false); concurrencyControlRequestParam.addStringAttribute("defaultValue", ""); parameterTypes.add(new AnnotatedJavaType(JavaType.STRING, concurrencyControlRequestParam .build())); new AnnotationMetadataBuilder(SpringJavaType.PUT_MAPPING); putMappingAnnotation.addStringAttribute("name", methodName.getSymbolName()); final InvocableMemberBodyBuilder bodyBuilder = new InvocableMemberBodyBuilder(); bodyBuilder.appendFormalLine("// Check if provided form contain errors"); bodyBuilder.appendFormalLine("if (result.hasErrors()) {"); String savedVarName = "saved" + entity.getSimpleTypeName(); entity.getSimpleTypeName(), entity.getSimpleTypeName(), entityItemName); return methodBuilder.build();
/** * 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(); }
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();
AnnotatedJavaType.convertFromAnnotatedJavaTypes(parameterTypes)); if (existingMethod != null) { return existingMethod; parameterNames.add(new JavaSymbolName("search")); parameterNames.add(new JavaSymbolName("pageable")); parameterNames.add(new JavaSymbolName("locale")); new AnnotationMetadataBuilder(GET_MAPPING); getMappingAnnotation.addEnumAttribute("produces", SpringJavaType.MEDIA_TYPE, "APPLICATION_JSON_VALUE"); getMappingAnnotation.addStringAttribute("name", methodName.getSymbolName()); getMappingAnnotation.addStringAttribute("value", "/s2"); annotations.add(getMappingAnnotation); this.mvcMethodNames.put(methodName.getSymbolName(), methodName.getSymbolName()); final InvocableMemberBodyBuilder bodyBuilder = new InvocableMemberBodyBuilder(); final String itemsName = StringUtils.uncapitalize(this.entityPlural); JavaType defaultReturnType = findAllMethod.getReturnType().getParameters().get(0); bodyBuilder.appendFormalLine("String idExpression = \"#{%s}\";", this.entityIdentifier); JavaType.wrapperOf(RESPONSE_ENTITY, JavaType.wrapperOf( SpringletsJavaType.SPRINGLETS_SELECT2_DATA_SUPPORT, defaultReturnType)); return methodBuilder.build();