/** * Builds createdBy field for storing user who creates entity registers * * @return FieldMetadataBuilder */ private FieldMetadataBuilder getCreatedByField(ClassOrInterfaceTypeDetails entityDetails, String columnName) { // Create field annotations List<AnnotationMetadataBuilder> annotations = new ArrayList<AnnotationMetadataBuilder>(); // Only add @Column if required by annotation @RooJpaAudit if (StringUtils.isNotBlank(columnName)) { AnnotationMetadataBuilder columnAnnotation = new AnnotationMetadataBuilder(JpaJavaType.COLUMN); columnAnnotation.addStringAttribute("name", columnName); annotations.add(columnAnnotation); } AnnotationMetadataBuilder createdDateAnnotation = new AnnotationMetadataBuilder(SpringJavaType.CREATED_BY); annotations.add(createdDateAnnotation); // Create field FieldDetails fieldDetails = new FieldDetails(PhysicalTypeIdentifier.createIdentifier(entityDetails), JavaType.STRING, new JavaSymbolName("createdBy")); fieldDetails.setModifiers(Modifier.PRIVATE); fieldDetails.setAnnotations(annotations); FieldMetadataBuilder fieldBuilder = new FieldMetadataBuilder(fieldDetails); return fieldBuilder; }
/** * This method generates the version field using the provided values * * @param entity * @param versionField * @param versionType * @param versionColumn * @return */ private FieldMetadata getVersionField(final JavaType entity, String versionField, final JavaType versionType, final String versionColumn) { if (StringUtils.isEmpty(versionField)) { versionField = "version"; } final List<AnnotationMetadataBuilder> annotations = new ArrayList<AnnotationMetadataBuilder>(); annotations.add(new AnnotationMetadataBuilder(VERSION)); if (StringUtils.isNotEmpty(versionColumn)) { final AnnotationMetadataBuilder columnBuilder = new AnnotationMetadataBuilder(COLUMN); columnBuilder.addStringAttribute("name", versionColumn); annotations.add(columnBuilder); } FieldDetails versionFieldDetails = new FieldDetails(getTypeLocationService().getPhysicalTypeIdentifier(entity), versionType, new JavaSymbolName(versionField)); versionFieldDetails.setModifiers(Modifier.PRIVATE); versionFieldDetails.addAnnotations(annotations); return new FieldMetadataBuilder(versionFieldDetails).build(); }
final JavaSymbolName fieldName = new JavaSymbolName("rnd" + StringUtils.repeat("_", index)); this.rndFieldName = fieldName; final FieldMetadata candidate = governorTypeDetails.getField(fieldName); if (!candidate.getFieldType().equals(RANDOM)) { return new FieldMetadataBuilder(candidate); final FieldMetadataBuilder fieldBuilder = new FieldMetadataBuilder(getId()); fieldBuilder.setModifier(Modifier.PRIVATE); fieldBuilder.setFieldName(fieldName); fieldBuilder.setFieldType(RANDOM); fieldBuilder.setFieldInitializer("new SecureRandom()"); CommentStructure comment = new CommentStructure(); comment.addComment(new JavadocComment("Random generator for the entities index."), CommentLocation.BEGINNING); fieldBuilder.setCommentStructure(comment);
@Override public FieldMetadata build() { final FieldMetadataBuilder fieldMetadataBuilder = new FieldMetadataBuilder(declaredByMetadataId); fieldMetadataBuilder.setAnnotations(annotations); fieldMetadataBuilder.setFieldInitializer(fieldInitializer); fieldMetadataBuilder.setFieldName(fieldName); fieldMetadataBuilder.setFieldType(fieldType); fieldMetadataBuilder.setModifier(modifier); return fieldMetadataBuilder.build(); } }
public FieldMetadata build() { DefaultFieldMetadata md = new DefaultFieldMetadata(getCustomData().build(), getDeclaredByMetadataId(), getModifier(), buildAnnotations(), getFieldName(), getFieldType(), getFieldInitializer()); md.setCommentStructure(getCommentStructure()); return md; }
private FieldMetadata getConversionServiceField() { return new FieldMetadataBuilder(getId(), Modifier.PRIVATE, new ArrayList<AnnotationMetadataBuilder>(), CONVERSION_SERVICE_FIELD_NAME, SpringJavaType.CONVERSION_SERVICE).build(); }
if (StringUtils.isEmpty(module.getModuleName())) { moduleStr = ""; if (!service.getModule().equals(StringUtils.EMPTY)) { getProjectOperations().addDependency(service.getModule(), DEPENDENCY_SPRINGLETS_MAIL); getTypeLocationService().getTypeDetails(service); Validate.isTrue(serviceTypeDetails != null, "Cannot locate source for '%s'", service.getFullyQualifiedTypeName()); cidBuilder.addField(new FieldMetadataBuilder(declaredByMetadataId, PRIVATE, Arrays .asList(new AnnotationMetadataBuilder(AUTOWIRED)), new JavaSymbolName("mailReceiver"), SpringletsJavaType.SPRINGLETS_MAIL_RECEIVER_SERVICE));
String methodName = method.getMethodName().getSymbolName(); for (AnnotatedJavaType paramType : method.getParameterTypes()) { JavaType javaType = paramType.getJavaType(); if (javaType.isPrimitive() && !javaType.isArray()) { if (JavaType.BOOLEAN_PRIMITIVE.equals(javaType)) { methodParamsToNull.add("false"); } else if (JavaType.INT_PRIMITIVE.equals(javaType)) { getConstantForMethodName(methodName).getFieldName()); bodyBuilder.indent(); getNameOfJavaType(SpringletsJavaType.SPRINGLETS_MVC_URI_COMPONENTS_BUILDER), this.getControllerClassMethod.getMethodName(), methodName, StringUtils.join(methodParamsToNull, ", "), PATH_VARIABLES_ARGUMENT_NAME); bodyBuilder.indentRemove(); new MethodMetadataBuilder(getId(), Modifier.PUBLIC, toUriMethodName, SpringJavaType.URI_COMPONENTS, parameterTypes, parameterNames, bodyBuilder); return methodBuilder.build();
ensureGovernorIsAnnotated(new AnnotationMetadataBuilder(SpringJavaType.CONFIGURATION)); ensureGovernorIsAnnotated(new AnnotationMetadataBuilder(new JavaType( "org.springframework.boot.autoconfigure.condition.ConditionalOnWebApplication"))); ensureGovernorHasField(new FieldMetadataBuilder(getLoggerField())); if (StringUtils.isNotEmpty(profile)) { AnnotationMetadataBuilder profileAnnotation = new AnnotationMetadataBuilder(SpringJavaType.PROFILE); profileAnnotation.addStringAttribute("value", profile); ensureGovernorIsAnnotated(profileAnnotation); ensureGovernorHasField(new FieldMetadataBuilder(getBusField())); ensureGovernorHasField(new FieldMetadataBuilder(getServletField())); ensureGovernorHasField(new FieldMetadataBuilder( getServiceField(endpointAndService.getValue()))); ensureGovernorHasMethod(new MethodMetadataBuilder( getEndpointMethod(endpointAndService.getKey()))); ensureGovernorHasMethod(new MethodMetadataBuilder(getOpenEntityManagerInViewFilterMethod()));
/** * This method returns service field included on controller that it * represents the service spent as parameter * * @param service * Searched service * @return The field that represents the service spent as parameter */ public static FieldMetadata getFieldFor(String declaredByMetadataId, JavaType service) { // Generating service field name String fieldName = new JavaSymbolName(service.getSimpleTypeName()).getSymbolNameUnCapitalisedFirstLetter(); return new FieldMetadataBuilder(declaredByMetadataId, Modifier.PRIVATE, new ArrayList<AnnotationMetadataBuilder>(), new JavaSymbolName(fieldName), service).build(); }
new JavaType(String.format("%s.%s", getPackageNameFromTargetNameSpace(targetNameSpace), StringUtils.capitalize(endPoint.getName()))); JavaSymbolName methodName = new JavaSymbolName(StringUtils.uncapitalize(endPoint.getName())); getNameOfJavaType(new JavaType("org.apache.cxf.jaxws.JaxWsProxyFactoryBean"))); .getFieldName()); if (endPoint.getBindingType().getField().getSymbolName().equals(SoapBindingType.SOAP12.name())) { getNameOfJavaType(new JavaType("javax.xml.ws.soap.SOAPBinding"))); getLoggerField().getFieldName(), getEndPointField(endPoint).getFieldName() .getSymbolNameCapitalisedFirstLetter(), getEndPointField(endPoint).getFieldName()); new MethodMetadataBuilder(getId(), Modifier.PUBLIC, methodName, endPointType, bodyBuilder); method.addAnnotation(new AnnotationMetadataBuilder(SpringJavaType.BEAN));
.getDeclaredField(curName); if (currentField != null) { if (!currentField.getFieldType().equals(fieldType)) { int i = 1; while (governorTypeDetails.getDeclaredField(newName) != null) { newName = new JavaSymbolName(curName.getSymbolName() .concat(StringUtils.repeat('_', i))); i++; final FieldMetadataBuilder fieldBuilder = new FieldMetadataBuilder( fieldBuilder.setFieldInitializer(initializer); currentField = fieldBuilder.build(); // Build and return a
if (field.getFieldType().getFullyQualifiedTypeName().equals("java.util.Set")) { JavaType fieldType = field.getFieldType().getParameters().get(0); fieldDetails = new SetField(projectionBuilder.getDeclaredByMetadataId(), new JavaType( fieldBuilder = new FieldMetadataBuilder(fieldDetails); fieldBuilder.setModifier(field.getModifier()); fieldBuilder.setAnnotations(field.getAnnotations()); fieldBuilder = new FieldMetadataBuilder(fieldDetails); fieldBuilder.setModifier(field.getModifier()); fieldBuilder.setAnnotations(field.getAnnotations()); } else { fieldBuilder = new FieldMetadataBuilder(projectionBuilder.getDeclaredByMetadataId(), field); fieldBuilder.setFieldName(new JavaSymbolName(entry.getKey())); fieldBuilder.setFieldInitializer(initializer); fieldBuilder.removeAnnotation(annotation.getAnnotationType()); fieldBuilder.removeAnnotation(annotation.getAnnotationType()); fieldBuilder.setModifier(Modifier.PRIVATE); FieldMetadata projectionField = fieldBuilder.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(); }
/** * This method provides the related field for the provided endPoint * * @param endPoint to obtain the related field * * @return FieldMetadataBuilder that contains all information about the field */ public FieldMetadataBuilder getEndPointField(WsClientEndpoint endPoint) { // Checking if already exists the endPoint field to // prevent to generate it again if (endPointFields.get(endPoint.getName()) != null) { return endPointFields.get(endPoint.getName()); } // Calculate the field name JavaSymbolName fieldName = new JavaSymbolName(StringUtils.uncapitalize(endPoint.getName()).concat("Url")); // Create the field FieldMetadataBuilder endPointField = new FieldMetadataBuilder(getId(), Modifier.PRIVATE, fieldName, JavaType.STRING, null); // Include @Value annotation AnnotationMetadataBuilder valueAnnotation = new AnnotationMetadataBuilder(SpringJavaType.VALUE); valueAnnotation.addStringAttribute("value", String.format("${url/%s}", endPoint.getName())); endPointField.addAnnotation(valueAnnotation); // Cache generated fields endPointFields.put(endPoint.getName(), endPointField); return endPointField; }
private MethodMetadata getNewRandomTransientEntityMethod() { new JavaSymbolName("getNewRandomTransient" + this.entity.getSimpleTypeName()); Validate.isTrue(userMethod.getReturnType().equals(entity), "Method '%s' on '%s' must return '%s'", methodName, this.destination, this.entity.getSimpleTypeName()); this.newTransientEntityMethod = userMethod; return userMethod; this.sizeAccesorName, getAccessorMethod(getRndField().build()).getMethodName()); getAccessorMethod(getEntityFactoryField().build()).getMethodName(), this.entityFactoryMetadata.getCreateFactoryMethodName()); new MethodMetadataBuilder(getId(), Modifier.PUBLIC, methodName, this.entity, bodyBuilder); "%1$s the generated transient {@link %1$s}", this.entity.getSimpleTypeName()), null); comment.addComment(javadocComment, CommentLocation.BEGINNING); methodBuilder.setCommentStructure(comment); this.newTransientEntityMethod = methodBuilder.build(); return this.newTransientEntityMethod;
this.entity = entity; this.getRandomIdMethodName = new JavaSymbolName(String.format("getRandom%sId", this.entity.getSimpleTypeName())); this.getRandomMethodName = String.format("getRandom%s", this.entity.getSimpleTypeName()); this.identifierType = identifierType; this.entityVar = StringUtils.uncapitalize(this.entity.getSimpleTypeName()); this.identifierAccessorMethodName = identifierAccessorMethodName; this.entityPlural = entityPlural; this.repositoryField = getRepositoryField().build(); ensureGovernorHasField(getRepositoryField()); this.dodField = getDodField().build(); ensureGovernorHasField(getDodField()); ensureGovernorHasMethod(new MethodMetadataBuilder(getBeforeMethod())); ensureGovernorHasMethod(new MethodMetadataBuilder(getCountTestMethod())); ensureGovernorHasMethod(new MethodMetadataBuilder(getFindOneTestMethod()));
"id", XmlUtils.convertId("fc:" + formBackingType.getFullyQualifiedTypeName())) .addAttribute("modelAttribute", entityName) .addAttribute("path", controllerPath) .getSimpleTypeName())) { formCreate.setAttribute("path", controllerPath); .isEmpty()) { final String identifierFieldName = formBackingTypePersistenceMetadata .getIdentifierField().getFieldName().getSymbolName(); formCreate.setAttribute("compositePkField", identifierFieldName); for (final FieldMetadata embeddedField : formBackingTypePersistenceMetadata .getRooIdentifierFields()) { final FieldMetadataBuilder fieldBuilder = new FieldMetadataBuilder( embeddedField); fieldBuilder .setFieldName(new JavaSymbolName(identifierFieldName + "." + embeddedField.getFieldName().getSymbolName())); for (int i = 0; i < fieldCopy.size(); i++) { formFields.add(fieldBuilder.build());
module = fieldDetails.getFieldType().getModule(); if (fieldDetails instanceof CollectionField) { final CollectionField collectionField = (CollectionField) fieldDetails; module = collectionField.getGenericParameterTypeName().getModule(); initializer = "new " + collectionField.getInitializer() + "()"; } else if (fieldDetails instanceof DateField && fieldDetails.getFieldName().getSymbolName().equals("created")) { initializer = "new Date()"; final FieldMetadataBuilder fieldBuilder = new FieldMetadataBuilder(fieldDetails); fieldBuilder.setFieldInitializer(initializer); typeManagementService.addField(fieldBuilder.build());
final String collaboratingFieldName = getCollaboratingFieldName(entityNeedingCollaborator, entityFactoryClasses) .getSymbolName(); final JavaSymbolName fieldSymbolName = new JavaSymbolName(collaboratingFieldName); final FieldMetadata candidate = governorTypeDetails.getField(fieldSymbolName); if (candidate != null) { .isTrue(candidate.getFieldType().equals(collaboratorType), "Field '%s' on '%s' must be of type '%s'", collaboratingFieldName, destination.getFullyQualifiedTypeName(), collaboratorType.getFullyQualifiedTypeName()); Validate.isTrue(Modifier.isPrivate(candidate.getModifier()), "Field '%s' on '%s' must be private", collaboratingFieldName, annotations.add(new AnnotationMetadataBuilder(AUTOWIRED)); builder.addField(new FieldMetadataBuilder(getId(), 0, annotations, fieldSymbolName, collaboratorType)); fields.add(fieldSymbolName);