Examples with AnnotationMetadataBuilder org.springframework.roo.classpath.details.annotations.AnnotationMetadataBuilder used on opensource projects

Example 46 with AnnotationMetadataBuilder

use of org.springframework.roo.classpath.details.annotations.AnnotationMetadataBuilder in project spring-roo by spring-projects.

the class ControllerOperationsImpl method getRooDetailAnnotation.

/**
 * Method that returns @RooDetail annotation
 *
 * @param relationField
 *            Field that set the relationship
 * @param viewsList
 *            Separated comma list that defines the parent views where the
 *            new detail will be displayed.
 * @return
 */
private AnnotationMetadataBuilder getRooDetailAnnotation(final String relationField, final String viewsList) {
    AnnotationMetadataBuilder annotationDetail = new AnnotationMetadataBuilder(RooJavaType.ROO_DETAIL);
    annotationDetail.addStringAttribute("relationField", relationField);
    // Including views attribute if needed
    if (StringUtils.isNotEmpty(viewsList)) {
        String[] views = viewsList.split(",");
        List<StringAttributeValue> viewsValues = new ArrayList<StringAttributeValue>();
        for (String view : views) {
            viewsValues.add(new StringAttributeValue(new JavaSymbolName("value"), view));
        }
        ArrayAttributeValue<StringAttributeValue> viewsAttr = new ArrayAttributeValue<StringAttributeValue>(new JavaSymbolName("views"), viewsValues);
        annotationDetail.addAttribute(viewsAttr);
    }
    return annotationDetail;
}

Example 47 with AnnotationMetadataBuilder

use of org.springframework.roo.classpath.details.annotations.AnnotationMetadataBuilder in project spring-roo by spring-projects.

the class ControllerOperationsImpl method createDomainModelModule.

/**
 * Create DomainModelModule.java class and adds it
 * {@link RooDomainModelModule} annotation
 *
 * @param module
 *            the Pom where configuration classes should be installed
 */
private void createDomainModelModule(Pom module) {
    // Create DomainModelModule.java class
    JavaType domainModelModule = new JavaType(String.format("%s.config.jackson.DomainModelModule", getTypeLocationService().getTopLevelPackageForModule(module)), module.getModuleName());
    Validate.notNull(domainModelModule.getModule(), "ERROR: Module name is required to generate a valid JavaType");
    final String domainModelModuleIdentifier = getPathResolver().getCanonicalPath(domainModelModule.getModule(), Path.SRC_MAIN_JAVA, domainModelModule);
    // Check if file already exists
    if (!getFileManager().exists(domainModelModuleIdentifier)) {
        // Creating class builder
        final String mid = PhysicalTypeIdentifier.createIdentifier(domainModelModule, getPathResolver().getPath(domainModelModuleIdentifier));
        final ClassOrInterfaceTypeDetailsBuilder typeBuilder = new ClassOrInterfaceTypeDetailsBuilder(mid, PUBLIC, domainModelModule, PhysicalTypeCategory.CLASS);
        // Generating @RooDomainModelModule annotation
        typeBuilder.addAnnotation(new AnnotationMetadataBuilder(RooJavaType.ROO_DOMAIN_MODEL_MODULE));
        // Write new class disk
        getTypeManagementService().createOrUpdateTypeOnDisk(typeBuilder.build());
    }
}

Example 48 with AnnotationMetadataBuilder

use of org.springframework.roo.classpath.details.annotations.AnnotationMetadataBuilder in project spring-roo by spring-projects.

the class ControllerOperationsImpl method createJsonDeserializersIfDontExists.

/**
 * Create the Json Desearializer utility class (annotated
 * with @RooDeserializer) for target Entity and its related entities if they
 * aren't created yet.
 *
 * @param entity
 * @param module
 * @param controllerPackage
 */
private void createJsonDeserializersIfDontExists(JavaType currentEntity, String module, JavaPackage controllerPackage) {
    List<JavaType> entitiesToCreateSerializers = getParentAndChildrenRelatedEntities(currentEntity);
    // Check if already exists a serializer for each entity
    Set<ClassOrInterfaceTypeDetails> allDeserializer = getTypeLocationService().findClassesOrInterfaceDetailsWithAnnotation(RooJavaType.ROO_DESERIALIZER);
    for (JavaType entity : entitiesToCreateSerializers) {
        EntityDeserializerAnnotationValues values;
        boolean deserializerFound = false;
        for (ClassOrInterfaceTypeDetails deserializer : allDeserializer) {
            values = new EntityDeserializerAnnotationValues(deserializer);
            if (entity.equals(values.getEntity())) {
                // Found mixing. Nothing to do.
                deserializerFound = true;
            }
        }
        if (!deserializerFound) {
            // Not found deserializer. Create it
            ClassOrInterfaceTypeDetails serviceDetails = getServiceLocator().getService(entity);
            Validate.notNull(serviceDetails, "Can't found service for Entity %s to generate " + "Serializer. If it is a related entity with the one to generate " + "controller, it needs a service.", entity.getFullyQualifiedTypeName());
            // Build @RooDeserializer
            List<AnnotationMetadataBuilder> annotations = new ArrayList<AnnotationMetadataBuilder>();
            annotations = new ArrayList<AnnotationMetadataBuilder>();
            AnnotationMetadataBuilder deserializerAnnotation = new AnnotationMetadataBuilder(RooJavaType.ROO_DESERIALIZER);
            deserializerAnnotation.addClassAttribute("entity", entity);
            annotations.add(deserializerAnnotation);
            JavaType deserializerClass = new JavaType(String.format("%s.%sDeserializer", controllerPackage.getFullyQualifiedPackageName(), entity.getSimpleTypeName()), module);
            final LogicalPath deserializerPath = getPathResolver().getPath(module, Path.SRC_MAIN_JAVA);
            final String resourceIdentifierItem = getTypeLocationService().getPhysicalTypeCanonicalPath(deserializerClass, deserializerPath);
            final String declaredByMetadataIdItem = PhysicalTypeIdentifier.createIdentifier(deserializerClass, getPathResolver().getPath(resourceIdentifierItem));
            ClassOrInterfaceTypeDetailsBuilder cidBuilder = new ClassOrInterfaceTypeDetailsBuilder(declaredByMetadataIdItem, Modifier.PUBLIC, deserializerClass, PhysicalTypeCategory.CLASS);
            cidBuilder.setAnnotations(annotations);
            /*
         * Moved extend to java (instead ITD) because there were
         * compilation problems when Mixin
         * uses @JsonDeserialize(using=EntityDeserializer.class)
         * annotation (requires extend of JsonDeseralizer)
         */
            cidBuilder.addExtendsTypes(JavaType.wrapperOf(JSON_OBJECT_DESERIALIZER, entity));
            FieldMetadata serviceField = EntityDeserializerMetadata.getFieldFor(declaredByMetadataIdItem, serviceDetails.getType());
            FieldMetadata conversionServiceField = EntityDeserializerMetadata.getFieldFor(declaredByMetadataIdItem, SpringJavaType.CONVERSION_SERVICE);
            cidBuilder.addField(serviceField);
            cidBuilder.addField(conversionServiceField);
            ConstructorMetadata constructor = EntityDeserializerMetadata.getConstructor(declaredByMetadataIdItem, serviceField, conversionServiceField);
            cidBuilder.addConstructor(constructor);
            getTypeManagementService().createOrUpdateTypeOnDisk(cidBuilder.build());
        }
    }
}

Example 49 with AnnotationMetadataBuilder

use of org.springframework.roo.classpath.details.annotations.AnnotationMetadataBuilder in project spring-roo by spring-projects.

the class ControllerOperationsImpl method createJsonMixinIfDontExists.

/**
 * Create the Json Mixin utility class (annotated with @RooJsonMixin) for
 * target Entity if it isn't created yet.
 *
 * @param entity
 * @param entityMetadata
 * @param requiresDeserializer
 * @param module
 * @param controllerPackage
 */
private void createJsonMixinIfDontExists(JavaType entity, JpaEntityMetadata entityMetadata, String module, JavaPackage controllerPackage) {
    Set<ClassOrInterfaceTypeDetails> allJsonMixin = getTypeLocationService().findClassesOrInterfaceDetailsWithAnnotation(RooJavaType.ROO_JSON_MIXIN);
    JSONMixinAnnotationValues values;
    for (ClassOrInterfaceTypeDetails mixin : allJsonMixin) {
        values = new JSONMixinAnnotationValues(mixin);
        if (entity.equals(values.getEntity())) {
            // Found mixing. Nothing to do.
            return;
        }
    }
    // Not found. Create class
    List<AnnotationMetadataBuilder> annotations = new ArrayList<AnnotationMetadataBuilder>();
    annotations = new ArrayList<AnnotationMetadataBuilder>();
    AnnotationMetadataBuilder mixinAnnotation = new AnnotationMetadataBuilder(RooJavaType.ROO_JSON_MIXIN);
    mixinAnnotation.addClassAttribute("entity", entity);
    annotations.add(mixinAnnotation);
    JavaType mixinClass = new JavaType(String.format("%s.%sJsonMixin", controllerPackage.getFullyQualifiedPackageName(), entity.getSimpleTypeName()), module);
    final LogicalPath mixinPath = getPathResolver().getPath(module, Path.SRC_MAIN_JAVA);
    final String resourceIdentifierItem = getTypeLocationService().getPhysicalTypeCanonicalPath(mixinClass, mixinPath);
    final String declaredByMetadataIdItem = PhysicalTypeIdentifier.createIdentifier(mixinClass, getPathResolver().getPath(resourceIdentifierItem));
    ClassOrInterfaceTypeDetailsBuilder cidBuilder = new ClassOrInterfaceTypeDetailsBuilder(declaredByMetadataIdItem, Modifier.PUBLIC + Modifier.ABSTRACT, mixinClass, PhysicalTypeCategory.CLASS);
    cidBuilder.setAnnotations(annotations);
    getTypeManagementService().createOrUpdateTypeOnDisk(cidBuilder.build());
}

Example 50 with AnnotationMetadataBuilder

use of org.springframework.roo.classpath.details.annotations.AnnotationMetadataBuilder in project spring-roo by spring-projects.

the class ControllerOperationsImpl method createDetailClass.

private boolean createDetailClass(String field, String controllerName, ControllerType type, JavaType entity, ControllerMVCResponseService responseType, JavaPackage controllerPackage, String pathPrefixController, String viewsList) {
    JavaType detailController = new JavaType(String.format("%s.%s", controllerPackage.getFullyQualifiedPackageName(), controllerName), controllerPackage.getModule());
    ClassOrInterfaceTypeDetails detailControllerDetails = getTypeLocationService().getTypeDetails(detailController);
    if (detailControllerDetails != null) {
        LOGGER.log(Level.INFO, String.format("ERROR: Class '%s' already exists inside your generated project.", detailController.getFullyQualifiedTypeName()));
        return false;
    }
    List<AnnotationMetadataBuilder> annotations = new ArrayList<AnnotationMetadataBuilder>();
    annotations.add(getRooControllerAnnotation(entity, pathPrefixController, type));
    annotations.add(getRooDetailAnnotation(field, viewsList));
    // Add responseType annotation. Don't use responseTypeService
    // annotate to
    // prevent multiple
    // updates of the .java file. Annotate operation will be used during
    // controller update.
    annotations.add(new AnnotationMetadataBuilder(responseType.getAnnotation()));
    final LogicalPath detailControllerPathItem = getPathResolver().getPath(detailController.getModule(), Path.SRC_MAIN_JAVA);
    final String resourceIdentifierItem = getTypeLocationService().getPhysicalTypeCanonicalPath(detailController, detailControllerPathItem);
    final String declaredByMetadataId = PhysicalTypeIdentifier.createIdentifier(detailController, getPathResolver().getPath(resourceIdentifierItem));
    ClassOrInterfaceTypeDetailsBuilder cidBuilder = new ClassOrInterfaceTypeDetailsBuilder(declaredByMetadataId, Modifier.PUBLIC, detailController, PhysicalTypeCategory.CLASS);
    cidBuilder.setAnnotations(annotations);
    getTypeManagementService().createOrUpdateTypeOnDisk(cidBuilder.build());
    // Create LinkFactory class
    if (responseType.getName().equals("THYMELEAF")) {
        createLinkFactoryClass(cidBuilder.getName());
    }
    if (getProjectOperations().isMultimoduleProject()) {
    // TODO
    // // Getting related service
    // JavaType relatedEntityService = null;
    // Set<ClassOrInterfaceTypeDetails> services =
    // getTypeLocationService()
    // .findClassesOrInterfaceDetailsWithAnnotation(RooJavaType.ROO_SERVICE);
    // Iterator<ClassOrInterfaceTypeDetails> itServices =
    // services.iterator();
    // 
    // while (itServices.hasNext()) {
    // ClassOrInterfaceTypeDetails existingService = itServices.next();
    // AnnotationAttributeValue<Object> entityAttr =
    // existingService.getAnnotation(RooJavaType.ROO_SERVICE).getAttribute("entity");
    // JavaType entityJavaType = (JavaType) entityAttr.getValue();
    // String entityField = relationFieldObject.get(field);
    // if (entityJavaType.getSimpleTypeName().equals(entityField)) {
    // relatedEntityService = existingService.getType();
    // break;
    // }
    // }
    // 
    // getProjectOperations().addModuleDependency(detailController.getModule(),
    // relatedEntityService.getModule());
    }
    return true;
}