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

Example 41 with ClassOrInterfaceTypeDetails

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

the class WsOperationsImpl method annotateClassIfNeeded.

/**
 * This method annotates the provided class with @RooJaxbEntity. If this class extends
 * other classes, and that classes annotates other classes, etc.
 * this method will annotate them.
 *
 * @param entityDetails
 */
private void annotateClassIfNeeded(ClassOrInterfaceTypeDetails entityDetails) {
    List<JavaType> extendsTypes = entityDetails.getExtendsTypes();
    for (JavaType extendsType : extendsTypes) {
        ClassOrInterfaceTypeDetails extendsTypeDetails = getTypeLocationService().getTypeDetails(extendsType);
        if (extendsTypeDetails != null && extendsTypeDetails.getAnnotation(RooJavaType.ROO_JPA_ENTITY) != null) {
            // If annotation has not been included before, add it.
            if (extendsTypeDetails.getAnnotation(RooJavaType.ROO_JAXB_ENTITY) == null) {
                ClassOrInterfaceTypeDetailsBuilder cidBuilder = new ClassOrInterfaceTypeDetailsBuilder(extendsTypeDetails);
                // Include @RooJaxbEntity annotation
                AnnotationMetadataBuilder jaxbEntityAnnotation = new AnnotationMetadataBuilder(RooJavaType.ROO_JAXB_ENTITY);
                cidBuilder.addAnnotation(jaxbEntityAnnotation);
                // Write entity class on disk
                getTypeManagementService().createOrUpdateTypeOnDisk(cidBuilder.build());
            }
            // have been annotated
            if (!extendsTypeDetails.getExtendsTypes().isEmpty()) {
                annotateClassIfNeeded(extendsTypeDetails);
            }
        }
    }
    // If annotation has not been included before, add it.
    if (entityDetails.getAnnotation(RooJavaType.ROO_JAXB_ENTITY) == null) {
        ClassOrInterfaceTypeDetailsBuilder cidBuilder = new ClassOrInterfaceTypeDetailsBuilder(entityDetails);
        // Include @RooJaxbEntity annotation
        AnnotationMetadataBuilder jaxbEntityAnnotation = new AnnotationMetadataBuilder(RooJavaType.ROO_JAXB_ENTITY);
        cidBuilder.addAnnotation(jaxbEntityAnnotation);
        // Write entity class on disk
        getTypeManagementService().createOrUpdateTypeOnDisk(cidBuilder.build());
    }
}

Example 42 with ClassOrInterfaceTypeDetails

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

the class WsOperationsImpl method annotateRelatedFieldsIfNeeded.

/**
 * This method annotates the provided class with @RooJaxbEntity. If this class extends
 * other classes, and that classes annotates other classes, etc.
 * this method will annotate them.
 *
 * @param entityDetails
 */
private void annotateRelatedFieldsIfNeeded(ClassOrInterfaceTypeDetails entityDetails) {
    // Getting details of the provided entity
    MemberDetails memberDetails = getMemberDetailsScanner().getMemberDetails(getClass().getName(), entityDetails);
    // Getting all its fields
    for (FieldMetadata entityField : memberDetails.getFields()) {
        // If is a relation field, should be annotated
        if (entityField.getAnnotation(JpaJavaType.ONE_TO_ONE) != null || entityField.getAnnotation(JpaJavaType.ONE_TO_MANY) != null || entityField.getAnnotation(JpaJavaType.MANY_TO_ONE) != null || entityField.getAnnotation(JpaJavaType.MANY_TO_MANY) != null) {
            // Getting details of the annotated field
            JavaType fieldType = entityField.getFieldType();
            if (fieldType.isCommonCollectionType()) {
                fieldType = fieldType.getBaseType();
            }
            ClassOrInterfaceTypeDetails fieldDetails = getTypeLocationService().getTypeDetails(fieldType);
            // If is a valid entity
            if (fieldDetails != null && fieldDetails.getAnnotation(RooJavaType.ROO_JPA_ENTITY) != null) {
                // Delegates in annotateClassIfNeeded to annotate the related class field
                annotateClassIfNeeded(fieldDetails);
            }
        }
    }
}

Example 43 with ClassOrInterfaceTypeDetails

use of org.springframework.roo.classpath.details.ClassOrInterfaceTypeDetails 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);
    }
}

Example 44 with ClassOrInterfaceTypeDetails

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

the class JaxbEntityMetadataProviderImpl method getMetadata.

@Override
protected ItdTypeDetailsProvidingMetadataItem getMetadata(final String metadataIdentificationString, final JavaType aspectName, final PhysicalTypeMetadata governorPhysicalTypeMetadata, final String itdFilename) {
    // Getting the annotated entity type
    JavaType annotatedEntity = governorPhysicalTypeMetadata.getType();
    // Getting the entity details
    ClassOrInterfaceTypeDetails entityDetails = getTypeLocationService().getTypeDetails(annotatedEntity);
    // Getting the plural
    String entityPlural = getPluralService().getPlural(entityDetails);
    // Getting JavaBean Metadata
    String javaBeanMetadataKey = JavaBeanMetadata.createIdentifier(entityDetails);
    JavaBeanMetadata javaBeanMetadata = getMetadataService().get(javaBeanMetadataKey);
    // Getting JpaEntity Metadata
    String jpaEntityMetadataKey = JpaEntityMetadata.createIdentifier(entityDetails);
    JpaEntityMetadata jpaEntityMetadata = getMetadataService().get(jpaEntityMetadataKey);
    if (javaBeanMetadata == null) {
        // Not ready for this metadata
        return null;
    }
    // Getting the @OneToMany and @ManyToOne getters
    Map<String, String> entityNames = new HashMap<String, String>();
    List<MethodMetadata> oneToManyGetters = new ArrayList<MethodMetadata>();
    List<MethodMetadata> manyToOneGetters = new ArrayList<MethodMetadata>();
    for (FieldMetadata field : entityDetails.getDeclaredFields()) {
        // Getting getter for the oneToMany field
        MethodMetadata getter = javaBeanMetadata.getAccesorMethod(field);
        if (getter != null && (field.getAnnotation(JpaJavaType.ONE_TO_MANY) != null || field.getAnnotation(JpaJavaType.MANY_TO_MANY) != null)) {
            String getterTypeName = getter.getReturnType().getBaseType().getSimpleTypeName().toLowerCase();
            oneToManyGetters.add(getter);
            entityNames.put(getterTypeName, getPluralService().getPlural(getterTypeName));
        } else if (getter != null && field.getAnnotation(JpaJavaType.MANY_TO_ONE) != null) {
            String getterTypeName = getter.getReturnType().getSimpleTypeName().toLowerCase();
            manyToOneGetters.add(getter);
            entityNames.put(getterTypeName, getPluralService().getPlural(getterTypeName));
        }
    }
    // Getting the identifier accessor only if the annotated class doesn't have
    // parent
    MethodMetadata identifierAccessor = null;
    if (jpaEntityMetadata != null && jpaEntityMetadata.getParent() == null) {
        identifierAccessor = jpaEntityMetadata.getCurrentIdentifierAccessor();
    }
    return new JaxbEntityMetadata(metadataIdentificationString, aspectName, governorPhysicalTypeMetadata, getProjectOperations().getTopLevelPackage(""), annotatedEntity, entityPlural, identifierAccessor, oneToManyGetters, manyToOneGetters, entityNames);
}

Example 45 with ClassOrInterfaceTypeDetails

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

the class WsCommands method existingServicesInterfaces.

/**
 * This method is an autocomplete indicator of the 'ws endpoint' command.
 *
 * This method provides all existing classes annotated with @RooService
 *
 * @param context
 * @return
 */
@CliOptionAutocompleteIndicator(command = "ws endpoint", param = "service", help = "--service parameter should be autocomplete with some existing class annotated with @RooService.")
public List<String> existingServicesInterfaces(ShellContext context) {
    // Getting currentText
    String currentText = context.getParameters().get("service");
    List<String> existingServicesInterfaces = new ArrayList<String>();
    Set<ClassOrInterfaceTypeDetails> allServices = getTypeLocationService().findClassesOrInterfaceDetailsWithAnnotation(RooJavaType.ROO_SERVICE);
    for (ClassOrInterfaceTypeDetails service : allServices) {
        String name = getClasspathOperations().replaceTopLevelPackageString(service, currentText);
        if (!existingServicesInterfaces.contains(name)) {
            existingServicesInterfaces.add(name);
        }
    }
    return existingServicesInterfaces;
}