use of org.springframework.roo.classpath.details.annotations.AnnotationMetadataBuilder in project spring-roo by spring-projects.
the class WsOperationsImpl method addSEI.
@Override
public void addSEI(JavaType service, JavaType sei, JavaType endpointClass, JavaType configClass, String profile, boolean force) {
Validate.notNull(service, "ERROR: Provide a valid service");
Validate.notNull(sei, "ERROR: Provide a valid sei");
// Check if provided service exists
ClassOrInterfaceTypeDetails serviceTypeDetails = getTypeLocationService().getTypeDetails(service);
Validate.notNull(serviceTypeDetails, "ERROR: Provide an existing service");
// Check if provided service is annotated with @RooService
AnnotationMetadata serviceAnnotation = serviceTypeDetails.getAnnotation(RooJavaType.ROO_SERVICE);
Validate.notNull(serviceAnnotation, "ERROR: Provide a valid service annotated with @RooService");
// Check if provided service has a related entity
AnnotationAttributeValue<JavaType> entityAttr = serviceAnnotation.getAttribute("entity");
Validate.notNull(entityAttr, "ERROR: The provided service is annotated with @RooService but doesn't " + "contains the 'entity' attribute");
JavaType relatedEntity = entityAttr.getValue();
Validate.notNull(relatedEntity, "ERROR: The provided service is annotated with @RooService but doesn't " + "contains a valid entity in the 'entity' attribute");
// Check if provided SEI is located in an application module
if (!isLocatedInApplicationModule(sei) && !force) {
LOGGER.log(Level.INFO, "ERROR: The provided SEI is not located in an application module.");
return;
}
// Check if the configClass is located in an application module
if (configClass != null && !isLocatedInApplicationModule(configClass) && !force) {
LOGGER.log(Level.INFO, "ERROR: The provided config class is not located in an application module.");
return;
}
// new one inside the provided SEI module using the provided SEI name and 'Endpoint' suffix.
if (endpointClass == null) {
endpointClass = new JavaType(String.format("%sEndpoint", sei.getFullyQualifiedTypeName()), sei.getModule());
}
// new one inside the provided SEI module using the provided SEI name and 'Configuration' suffix
if (configClass == null) {
configClass = new JavaType(String.format("%sConfiguration", sei.getFullyQualifiedTypeName()), sei.getModule());
}
// Check if provided configClass exists or should be generated
boolean isNewConfigClass = false;
ClassOrInterfaceTypeDetails configClassDetails = getTypeLocationService().getTypeDetails(configClass);
if (configClassDetails == null) {
isNewConfigClass = true;
}
// If it have it, it should match with the provided one the provided one
if (!isNewConfigClass) {
MemberDetails configClassMemberDetails = getMemberDetailsScanner().getMemberDetails(getClass().getName(), configClassDetails);
AnnotationMetadata configurationAnnotation = configClassMemberDetails.getAnnotation(SpringJavaType.CONFIGURATION);
if (configurationAnnotation == null) {
LOGGER.log(Level.INFO, "ERROR: The provided class is not annotated with @Configuration so is not possible to include Web Service client configuration on it." + "Specify other configuration class that contains @Configuration annotation or specify a not existing class to generate it.");
return;
}
if (StringUtils.isNotEmpty(profile)) {
AnnotationMetadata profileAnnotation = configClassMemberDetails.getAnnotation(SpringJavaType.PROFILE);
if (profileAnnotation != null) {
String profiles = (String) profileAnnotation.getAttribute("value").getValue();
String[] definedProfiles = profiles.split(",");
boolean profileExists = false;
for (String definedProfile : definedProfiles) {
if (definedProfile.equals(profile)) {
profileExists = true;
}
}
if (!profileExists) {
LOGGER.log(Level.INFO, "ERROR: The provided configuration class doesn't work in the provided profile. " + "Use a different configuration class or use a different profile.");
return;
}
}
}
}
// Check if some the provided classes that should be generated already exists
if (getTypeLocationService().getTypeDetails(sei) != null) {
LOGGER.log(Level.INFO, "ERROR: The provided SEI already exists. Specify a different one using" + " --sei parameter.");
return;
}
if (getTypeLocationService().getTypeDetails(endpointClass) != null) {
LOGGER.log(Level.INFO, "ERROR: The provided Endpoint class already exists. Specify a different one using" + " --class parameter.");
return;
}
// Include necessary dependencies
includeDependenciesAndPluginsForSei(sei.getModule());
// Include the necessary properties using the provided profile
getApplicationConfigService().addProperty(sei.getModule(), "cxf.path", "/services", profile, true);
getApplicationConfigService().addProperty(sei.getModule(), "cxf.servlet.load-on-startup", "-1", profile, true);
// Generate the new SEI
final String seiIdentifier = getPathResolver().getCanonicalPath(sei.getModule(), Path.SRC_MAIN_JAVA, sei);
final String midSEI = PhysicalTypeIdentifier.createIdentifier(sei, getPathResolver().getPath(seiIdentifier));
ClassOrInterfaceTypeDetailsBuilder cidBuilderSEI = new ClassOrInterfaceTypeDetailsBuilder(midSEI, Modifier.PUBLIC, sei, PhysicalTypeCategory.INTERFACE);
// Create new @RooWsEndpoint annotation
AnnotationMetadataBuilder seiAnnotation = new AnnotationMetadataBuilder(new JavaType(RooSei.class));
// Including service parameter to @RooSei annotation
seiAnnotation.addClassAttribute("service", service);
// Include new @RooSei annotation
cidBuilderSEI.addAnnotation(seiAnnotation);
// Write SEI class on disk
getTypeManagementService().createOrUpdateTypeOnDisk(cidBuilderSEI.build());
// Generate the new Endpoint
final String endpointIdentifier = getPathResolver().getCanonicalPath(endpointClass.getModule(), Path.SRC_MAIN_JAVA, endpointClass);
final String midEndpoint = PhysicalTypeIdentifier.createIdentifier(endpointClass, getPathResolver().getPath(endpointIdentifier));
ClassOrInterfaceTypeDetailsBuilder cidBuilderEndpoint = new ClassOrInterfaceTypeDetailsBuilder(midEndpoint, Modifier.PUBLIC, endpointClass, PhysicalTypeCategory.CLASS);
// Create new @RooSeiImpl annotation
AnnotationMetadataBuilder endpointAnnotation = new AnnotationMetadataBuilder(new JavaType(RooSeiImpl.class));
// Include sei parameter to @RooSeiImpl annotation
endpointAnnotation.addClassAttribute("sei", sei);
// Include new @RooSeiImpl annotation
cidBuilderEndpoint.addAnnotation(endpointAnnotation);
// Include implements
cidBuilderEndpoint.addImplementsType(sei);
// Write endpoint class on disk
getTypeManagementService().createOrUpdateTypeOnDisk(cidBuilderEndpoint.build());
// If configuration class exists, check if is already annotated and update it.
// If not exists, create a new one
ClassOrInterfaceTypeDetailsBuilder cidBuilderConfig = null;
if (!isNewConfigClass) {
// Obtain builder from the existing class
cidBuilderConfig = new ClassOrInterfaceTypeDetailsBuilder(configClassDetails);
// Check if already have @RooWsEndpoints annotation
AnnotationMetadataBuilder wsEndpointsAnnotation = cidBuilderConfig.getDeclaredTypeAnnotation(RooJavaType.ROO_WS_ENDPOINTS);
if (wsEndpointsAnnotation != null) {
// Update the existing one
AnnotationAttributeValue<?> existingEndPoints = wsEndpointsAnnotation.build().getAttribute("endpoints");
List<?> values = (List<?>) existingEndPoints.getValue();
if (values != null) {
// Check if the provided endpoint exists yet in this config class
Iterator<?> it = values.iterator();
boolean alreadyManaged = false;
while (it.hasNext()) {
ClassAttributeValue existingEndPointAttr = (ClassAttributeValue) it.next();
JavaType existingEndPoint = existingEndPointAttr.getValue();
if (existingEndPoint.getFullyQualifiedTypeName().equals(endpointClass.getFullyQualifiedTypeName())) {
alreadyManaged = true;
}
}
// If endpoint already exists, show an error indicating that this endpoint is already managed
if (alreadyManaged) {
LOGGER.log(Level.INFO, "ERROR: The provided endpoint is already defined in the provided configuration class. " + "Specify some different configuration class.");
return;
} else {
// Update existing annotation with the new endPoint
Iterator<?> iterator = values.iterator();
List<AnnotationAttributeValue<?>> endpoints = new ArrayList<AnnotationAttributeValue<?>>();
while (iterator.hasNext()) {
ClassAttributeValue existingEndPoint = (ClassAttributeValue) iterator.next();
endpoints.add(existingEndPoint);
}
// Create @RooWsEndpoints annotation
ClassAttributeValue newEndpoint = new ClassAttributeValue(new JavaSymbolName("value"), endpointClass);
endpoints.add(newEndpoint);
ArrayAttributeValue<AnnotationAttributeValue<?>> newEndpoints = new ArrayAttributeValue<AnnotationAttributeValue<?>>(new JavaSymbolName("endpoints"), endpoints);
wsEndpointsAnnotation.addAttribute(newEndpoints);
}
}
} else {
// If not exists, add it with the new elements
wsEndpointsAnnotation = new AnnotationMetadataBuilder(new JavaType(RooWsEndpoints.class));
// Generate new list of endpoints
List<AnnotationAttributeValue<?>> endpoints = new ArrayList<AnnotationAttributeValue<?>>();
ClassAttributeValue newEndpoint = new ClassAttributeValue(new JavaSymbolName("value"), endpointClass);
endpoints.add(newEndpoint);
ArrayAttributeValue<AnnotationAttributeValue<?>> newEndpoints = new ArrayAttributeValue<AnnotationAttributeValue<?>>(new JavaSymbolName("endpoints"), endpoints);
wsEndpointsAnnotation.addAttribute(newEndpoints);
// Check if is necessary to include profile attribute
if (StringUtils.isNotEmpty(profile)) {
wsEndpointsAnnotation.addStringAttribute("profile", profile);
}
// Include new @RooWsEndpoints annotation
cidBuilderConfig.addAnnotation(wsEndpointsAnnotation);
}
} else {
// Create the specified configuration class and annotate it with necessary information
final String configClassIdentifier = getPathResolver().getCanonicalPath(configClass.getModule(), Path.SRC_MAIN_JAVA, configClass);
final String mid = PhysicalTypeIdentifier.createIdentifier(configClass, getPathResolver().getPath(configClassIdentifier));
cidBuilderConfig = new ClassOrInterfaceTypeDetailsBuilder(mid, Modifier.PUBLIC, configClass, PhysicalTypeCategory.CLASS);
// Create new @RooWsEndpoints annotation and include the new endpoint
// as endpoints attribute
List<AnnotationAttributeValue<?>> endpoints = new ArrayList<AnnotationAttributeValue<?>>();
ClassAttributeValue endPointAttributeValue = new ClassAttributeValue(new JavaSymbolName("value"), endpointClass);
endpoints.add(endPointAttributeValue);
ArrayAttributeValue<AnnotationAttributeValue<?>> newEndpoints = new ArrayAttributeValue<AnnotationAttributeValue<?>>(new JavaSymbolName("endpoints"), endpoints);
AnnotationMetadataBuilder wsEndpointsAnnotation = new AnnotationMetadataBuilder(new JavaType(RooWsEndpoints.class));
wsEndpointsAnnotation.addAttribute(newEndpoints);
// Include new @RooWsEndpoints annotation
cidBuilderConfig.addAnnotation(wsEndpointsAnnotation);
// doesn't exists yet, because we're generating a new @Configuration class
if (StringUtils.isNotEmpty(profile)) {
wsEndpointsAnnotation.addStringAttribute("profile", profile);
}
}
// Write config class on disk
getTypeManagementService().createOrUpdateTypeOnDisk(cidBuilderConfig.build());
// After create the SEI and the Endpoint, is necessary to annotate related entity with
// some JAX-B annotations if has not been annotated before
/*ClassOrInterfaceTypeDetails entityDetails =
getTypeLocationService().getTypeDetails(relatedEntity);
if (entityDetails != null) {
// Annotate the entity with @RooJaxbEntity. If this entity has a super class or that
// super class has another super class, etc. is necessary to annotate it too.
annotateClassIfNeeded(entityDetails);
// Also, is necessary to annotate @OneToMany, @ManyToOne and @ManyToMany fields detected in
// this class and in the super classes.
annotateRelatedFieldsIfNeeded(entityDetails);
}*/
// Provisional changes to annotate all entities
Set<ClassOrInterfaceTypeDetails> allEntities = getTypeLocationService().findClassesOrInterfaceDetailsWithAnnotation(RooJavaType.ROO_JPA_ENTITY);
for (ClassOrInterfaceTypeDetails entity : allEntities) {
// Annotate the entity with @RooJaxbEntity. If this entity has a super class or that
// super class has another super class, etc. is necessary to annotate it too.
annotateClassIfNeeded(entity);
// Also, is necessary to annotate @OneToMany, @ManyToOne and @ManyToMany fields detected in
// this class and in the super classes.
annotateRelatedFieldsIfNeeded(entity);
}
}
use of org.springframework.roo.classpath.details.annotations.AnnotationMetadataBuilder in project spring-roo by spring-projects.
the class JaxbEntityMetadata method getXmlIdentityInfoMethod.
/**
* This method returns the getXmlIdentityInfo() method.
*
* @return MethodMetadata that contains the getXmlIdentityInfoMethod
*/
public MethodMetadata getXmlIdentityInfoMethod() {
// Check if already exists
if (xmlIdentityInfoMethod != null) {
return xmlIdentityInfoMethod;
}
// If not, generate a new one
InvocableMemberBodyBuilder bodyBuilder = new InvocableMemberBodyBuilder();
// return getClass().getName() + ":" + getId();
bodyBuilder.appendFormalLine(String.format("return getClass().getName() + \":\" + %s();", identifierAccessor.getMethodName()));
MethodMetadataBuilder method = new MethodMetadataBuilder(getId(), Modifier.PUBLIC, new JavaSymbolName("getXmlIdentityInfo"), JavaType.STRING, bodyBuilder);
method.addAnnotation(new AnnotationMetadataBuilder(JavaType.XML_ID));
AnnotationMetadataBuilder xmlAttributeAnnotation = new AnnotationMetadataBuilder(JavaType.XML_ATTRIBUTE);
xmlAttributeAnnotation.addStringAttribute("name", "id");
method.addAnnotation(xmlAttributeAnnotation);
CommentStructure comment = new CommentStructure();
comment.addComment(new JavadocComment("Must return an unique ID across all entities"), CommentLocation.BEGINNING);
method.setCommentStructure(comment);
xmlIdentityInfoMethod = method.build();
return xmlIdentityInfoMethod;
}
use of org.springframework.roo.classpath.details.annotations.AnnotationMetadataBuilder in project spring-roo by spring-projects.
the class WsClientsMetadata method getEndPointField.
/**
* 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) {
// 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;
}
use of org.springframework.roo.classpath.details.annotations.AnnotationMetadataBuilder in project spring-roo by spring-projects.
the class WsEndpointsMetadata method getServletField.
/**
* This method obtains the servlet field that will be used in some different methods
*
* @return FieldMetadata that contains all the necessary information
* about the servlet field
*/
private FieldMetadata getServletField() {
// Check if already exists
if (this.servletField != null) {
return this.servletField;
}
// Create the field
FieldMetadataBuilder servlet = new FieldMetadataBuilder(getId(), Modifier.PRIVATE, new JavaSymbolName("cxfServletPath"), JavaType.STRING, null);
AnnotationMetadataBuilder valueAnnotation = new AnnotationMetadataBuilder(SpringJavaType.VALUE);
valueAnnotation.addStringAttribute("value", "${cxf.path}");
servlet.addAnnotation(valueAnnotation);
servletField = servlet.build();
return servletField;
}
use of org.springframework.roo.classpath.details.annotations.AnnotationMetadataBuilder in project spring-roo by spring-projects.
the class WsEndpointsMetadata method getOpenEntityManagerInViewFilterMethod.
/**
* This method obtains the method that register the openEntityManagerInView
* filter
*
* @return MethodMetadata with the information about the new method
*/
private MethodMetadata getOpenEntityManagerInViewFilterMethod() {
// Check if already exists
if (openEntityManagerInViewFilterMethod != null) {
return openEntityManagerInViewFilterMethod;
}
JavaType filterRegistrationBeanType = new JavaType("org.springframework.boot.context.embedded.FilterRegistrationBean");
// Generating method body
InvocableMemberBodyBuilder bodyBuilder = new InvocableMemberBodyBuilder();
// FilterRegistrationBean filterRegBean = new FilterRegistrationBean();
bodyBuilder.appendFormalLine("%s filterRegBean = new FilterRegistrationBean();", getNameOfJavaType(filterRegistrationBeanType));
// filterRegBean.setFilter(new OpenEntityManagerInViewFilter());
bodyBuilder.appendFormalLine("filterRegBean.setFilter(new %s());", getNameOfJavaType(new JavaType("org.springframework.orm.jpa.support.OpenEntityManagerInViewFilter")));
// List<String> urlPatterns = new ArrayList<String>();
bodyBuilder.appendFormalLine("%s<String> urlPatterns = new %s<String>();", getNameOfJavaType(JavaType.LIST), getNameOfJavaType(JavaType.ARRAY_LIST));
// urlPatterns.add(this.cxfServletPath + "/*");
bodyBuilder.appendFormalLine("urlPatterns.add(%s() + \"/*\");", getAccessorMethod(getServletField()).getMethodName());
// filterRegBean.setUrlPatterns(urlPatterns);
bodyBuilder.appendFormalLine("filterRegBean.setUrlPatterns(urlPatterns);");
// if (LOG.isDebugEnabled()) {
bodyBuilder.appendFormalLine("if (%s().isDebugEnabled()) {", getAccessorMethod(getLoggerField()).getMethodName());
// LOG.debug("Registering the 'OpenEntityManagerInViewFilter' filter for the '"
bodyBuilder.indent();
bodyBuilder.appendFormalLine("%s().debug(\"Registering the 'OpenEntityManagerInViewFilter' filter for the '\"", getAccessorMethod(getLoggerField()).getMethodName());
// .concat(this.cxfServletPath + "/*").concat("' URL."));
bodyBuilder.indent();
bodyBuilder.appendFormalLine(".concat(%s() + \"/*\").concat(\"' URL.\"));", getAccessorMethod(getServletField()).getMethodName());
bodyBuilder.indentRemove();
bodyBuilder.indentRemove();
// }
bodyBuilder.appendFormalLine("}");
// return filterRegBean;
bodyBuilder.appendFormalLine("return filterRegBean;");
MethodMetadataBuilder method = new MethodMetadataBuilder(getId(), Modifier.PUBLIC, new JavaSymbolName("openEntityManagerInViewFilter"), filterRegistrationBeanType, bodyBuilder);
method.addAnnotation(new AnnotationMetadataBuilder(SpringJavaType.BEAN));
openEntityManagerInViewFilterMethod = method.build();
return openEntityManagerInViewFilterMethod;
}
Aggregations