Examples with EnumDetails org.springframework.roo.model.EnumDetails used on opensource projects

Example 21 with EnumDetails

use of org.springframework.roo.model.EnumDetails in project spring-roo by spring-projects.

the class WsOperationsImpl method getWsClientAnnotation.

/**
 * This method provides @RooWsClient annotation with all the necessary attributes
 *
 * @param endpoint
 * @param targetNamespace
 * @param bindingType
 * @return
 */
private AnnotationMetadataBuilder getWsClientAnnotation(final String endpoint, final String targetNamespace, final SoapBindingType bindingType) {
    final List<AnnotationAttributeValue<?>> wsClientAttributes = new ArrayList<AnnotationAttributeValue<?>>();
    wsClientAttributes.add(new StringAttributeValue(new JavaSymbolName("endpoint"), endpoint));
    wsClientAttributes.add(new StringAttributeValue(new JavaSymbolName("targetNamespace"), targetNamespace));
    wsClientAttributes.add(new EnumAttributeValue(new JavaSymbolName("binding"), new EnumDetails(RooJavaType.ROO_ENUM_SOAP_BINDING_TYPE, new JavaSymbolName(bindingType.name()))));
    return new AnnotationMetadataBuilder(RooJavaType.ROO_WS_CLIENT, wsClientAttributes);
}

Example 22 with EnumDetails

use of org.springframework.roo.model.EnumDetails in project spring-roo by spring-projects.

the class WsOperationsImpl method addWsClient.

@Override
public void addWsClient(String wsdlLocation, String endPoint, JavaType configClass, SoapBindingType bindingType, String serviceUrl, String profile) {
    Validate.notEmpty(wsdlLocation, "ERROR: Provide a valid wsdlLocation");
    Validate.notEmpty(endPoint, "ERROR: Provide a valid endPoint");
    Validate.notNull(configClass, "ERROR: Provide a valid configClass");
    // Check if the configClass is located in an application module
    if (!isLocatedInApplicationModule(configClass)) {
        LOGGER.log(Level.INFO, "ERROR: The provided config class is not located in an application module.");
        return;
    }
    // Getting module from the .wsdl file
    final Pom wsdlModule = getModuleFromWsdlLocation(wsdlLocation);
    final String wsdlModuleName = wsdlModule.getModuleName();
    // Getting the wsdlName without the module
    final String wsdlName = getWsdlNameWithoutModule(wsdlLocation);
    // Getting wsdl absolute path from the provided wsdlLocation
    final String wsdlPath = getWsdlAbsolutePathFromWsdlName(wsdlLocation);
    // Check if provided .wsdl exists
    Validate.isTrue(getFileManager().exists(wsdlPath), "ERROR: You must provide an existing .wsdl file.");
    // the configClass module and the .wsdl module
    if (wsdlModuleName != configClass.getModule()) {
        getProjectOperations().addDependency(configClass.getModule(), new Dependency(wsdlModule.getGroupId(), wsdlModule.getArtifactId(), null));
    }
    // 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;
                }
            }
        }
    }
    // Obtain the service URL from the provided .wsdl file if empty
    if (StringUtils.isEmpty(serviceUrl)) {
        serviceUrl = getServiceUrlForEndpointFromWsdlFile(endPoint, wsdlPath);
        Validate.notEmpty(serviceUrl, "ERROR: It has not been possible to obtain the URL of the service from the provided .wsdl file. Indicate some serviceUrl using --serviceUrl parameter");
    }
    // Obtain the binding type from the provided .wsdl file if empty
    if (bindingType == null) {
        bindingType = getBindingTypeFromWsdlFile(wsdlPath);
        Validate.notNull(bindingType, "ERROR: It has not been possible to obtain the BindingType of the service from the provided .wsdl file. Indicate an specific BindingType using --binding parameter");
    }
    // Always is necessary to obtain the targetNameSpace from the provided .wsdl file
    String targetNameSpace = getTargetNameSpaceFromWsdlFile(wsdlPath);
    Validate.notEmpty(targetNameSpace, "ERROR: It has not been possible to obtain the targetNamespace of the service from the provided .wsdl file. Check if your .wsdl file has the correct format.");
    // Include necessary dependencies and plugins
    includeDependenciesAndPluginsForWsClient(wsdlName, wsdlModuleName);
    // Include the necessary properties using the provided profile
    getApplicationConfigService().addProperty(configClass.getModule(), "url/".concat(endPoint), serviceUrl, profile, true);
    // Generating the new configuration class if not exists
    // If provided class already exists, update it
    ClassOrInterfaceTypeDetailsBuilder cidBuilder = null;
    if (!isNewConfigClass) {
        // Obtain builder from the existing class
        cidBuilder = new ClassOrInterfaceTypeDetailsBuilder(configClassDetails);
        // Check if already have @RooWsClients annotation
        AnnotationMetadataBuilder wsClientsAnnotation = cidBuilder.getDeclaredTypeAnnotation(RooJavaType.ROO_WS_CLIENTS);
        if (wsClientsAnnotation != null) {
            // Update the existing one
            AnnotationAttributeValue<?> existingEndPoints = wsClientsAnnotation.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()) {
                    NestedAnnotationAttributeValue existingEndPoint = (NestedAnnotationAttributeValue) it.next();
                    String existingEndpointName = (String) existingEndPoint.getValue().getAttribute("endpoint").getValue();
                    if (existingEndpointName.equals(endPoint)) {
                        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()) {
                        NestedAnnotationAttributeValue existingEndPoint = (NestedAnnotationAttributeValue) iterator.next();
                        String existingEndpointName = (String) existingEndPoint.getValue().getAttribute("endpoint").getValue();
                        String existingEndpointNameSpace = (String) existingEndPoint.getValue().getAttribute("targetNamespace").getValue();
                        EnumDetails existingType = (EnumDetails) existingEndPoint.getValue().getAttribute("binding").getValue();
                        // Create @RooWsClient annotation
                        NestedAnnotationAttributeValue existingEndpoint = new NestedAnnotationAttributeValue(new JavaSymbolName("value"), getWsClientAnnotation(existingEndpointName, existingEndpointNameSpace, existingType).build());
                        endpoints.add(existingEndpoint);
                    }
                    // Create @RooWsClient annotation
                    NestedAnnotationAttributeValue newEndpoint = new NestedAnnotationAttributeValue(new JavaSymbolName("value"), getWsClientAnnotation(endPoint, targetNameSpace, bindingType).build());
                    endpoints.add(newEndpoint);
                    ArrayAttributeValue<AnnotationAttributeValue<?>> newEndpoints = new ArrayAttributeValue<AnnotationAttributeValue<?>>(new JavaSymbolName("endpoints"), endpoints);
                    wsClientsAnnotation.addAttribute(newEndpoints);
                }
            }
        } else {
            // If not exists, add it with the new elements
            wsClientsAnnotation = new AnnotationMetadataBuilder(new JavaType(RooWsClients.class));
            // Create @RooWsClient annotation
            List<AnnotationAttributeValue<?>> endpoints = new ArrayList<AnnotationAttributeValue<?>>();
            NestedAnnotationAttributeValue newEndpoint = new NestedAnnotationAttributeValue(new JavaSymbolName("value"), getWsClientAnnotation(endPoint, targetNameSpace, bindingType).build());
            endpoints.add(newEndpoint);
            ArrayAttributeValue<AnnotationAttributeValue<?>> newEndpoints = new ArrayAttributeValue<AnnotationAttributeValue<?>>(new JavaSymbolName("endpoints"), endpoints);
            wsClientsAnnotation.addAttribute(newEndpoints);
            if (StringUtils.isNotEmpty(profile)) {
                wsClientsAnnotation.addStringAttribute("profile", profile);
            }
            // Include new @RooWsClients annotation
            cidBuilder.addAnnotation(wsClientsAnnotation);
        }
    } else {
        // Create new configuration class
        final String configClassIdentifier = getPathResolver().getCanonicalPath(configClass.getModule(), Path.SRC_MAIN_JAVA, configClass);
        final String mid = PhysicalTypeIdentifier.createIdentifier(configClass, getPathResolver().getPath(configClassIdentifier));
        cidBuilder = new ClassOrInterfaceTypeDetailsBuilder(mid, Modifier.PUBLIC, configClass, PhysicalTypeCategory.CLASS);
        // Create new @RooWsClients annotation
        AnnotationMetadataBuilder wsClientsAnnotation = new AnnotationMetadataBuilder(new JavaType(RooWsClients.class));
        // Create @RooWsClient annotation
        List<AnnotationAttributeValue<?>> endpoints = new ArrayList<AnnotationAttributeValue<?>>();
        NestedAnnotationAttributeValue newEndpoint = new NestedAnnotationAttributeValue(new JavaSymbolName("value"), getWsClientAnnotation(endPoint, targetNameSpace, bindingType).build());
        endpoints.add(newEndpoint);
        ArrayAttributeValue<AnnotationAttributeValue<?>> newEndpoints = new ArrayAttributeValue<AnnotationAttributeValue<?>>(new JavaSymbolName("endpoints"), endpoints);
        wsClientsAnnotation.addAttribute(newEndpoints);
        if (StringUtils.isNotEmpty(profile)) {
            wsClientsAnnotation.addStringAttribute("profile", profile);
        }
        // Include new @RooWsClients annotation
        cidBuilder.addAnnotation(wsClientsAnnotation);
    }
    getTypeManagementService().createOrUpdateTypeOnDisk(cidBuilder.build());
    // Compile project to be able to generate necessary resources.
    // Is necessary to create new thread and wat for it.
    Thread generateSourcesThread = new Thread() {

        public void run() {
            try {
                Thread.sleep(1000);
                final StringBuilder sb = new StringBuilder();
                sb.append(LINE_SEPARATOR);
                sb.append(LINE_SEPARATOR);
                sb.append("##########################################################").append(LINE_SEPARATOR);
                sb.append("##########################################################").append(LINE_SEPARATOR);
                sb.append("################# Generating client sources ##############").append(LINE_SEPARATOR);
                sb.append("##########################################################").append(LINE_SEPARATOR);
                sb.append("##########################################################").append(LINE_SEPARATOR);
                sb.append("#").append(LINE_SEPARATOR);
                sb.append("# Please wait...").append(LINE_SEPARATOR);
                sb.append("# Don't execute any command until this operation finishes.").append(LINE_SEPARATOR);
                sb.append("#").append(LINE_SEPARATOR);
                sb.append(LINE_SEPARATOR);
                sb.append(LINE_SEPARATOR);
                LOGGER.log(Level.INFO, sb.toString());
                // Changing focus to the module where the .wsdl file is located
                getProjectOperations().setModule(wsdlModule);
                // executing mvn generate-sources command
                getMavenOperations().executeMvnCommand("generate-sources");
            } catch (InterruptedException e) {
                e.printStackTrace();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    };
    generateSourcesThread.start();
}

Example 23 with EnumDetails

use of org.springframework.roo.model.EnumDetails in project spring-roo by spring-projects.

the class DbreMetadata method addCascadeType.

private void addCascadeType(final AnnotationMetadataBuilder annotationBuilder, final CascadeAction onUpdate, final CascadeAction onDelete) {
    final String attributeName = "cascade";
    boolean hasCascadeType = true;
    if (onUpdate == CascadeAction.CASCADE && onDelete == CascadeAction.CASCADE) {
        annotationBuilder.addEnumAttribute(attributeName, CASCADE_TYPE, "ALL");
    } else if (onUpdate == CascadeAction.CASCADE && onDelete != CascadeAction.CASCADE) {
        final List<EnumAttributeValue> arrayValues = new ArrayList<EnumAttributeValue>();
        arrayValues.add(new EnumAttributeValue(new JavaSymbolName(attributeName), new EnumDetails(CASCADE_TYPE, new JavaSymbolName("PERSIST"))));
        arrayValues.add(new EnumAttributeValue(new JavaSymbolName(attributeName), new EnumDetails(CASCADE_TYPE, new JavaSymbolName("MERGE"))));
        annotationBuilder.addAttribute(new ArrayAttributeValue<EnumAttributeValue>(new JavaSymbolName(attributeName), arrayValues));
    } else if (onUpdate != CascadeAction.CASCADE && onDelete == CascadeAction.CASCADE) {
        annotationBuilder.addEnumAttribute(attributeName, CASCADE_TYPE.getSimpleTypeName(), "REMOVE");
    } else {
        hasCascadeType = false;
    }
    if (hasCascadeType) {
        builder.getImportRegistrationResolver().addImport(CASCADE_TYPE);
    }
}

Example 24 with EnumDetails

use of org.springframework.roo.model.EnumDetails in project spring-roo by spring-projects.

the class JspOperationsImpl method getHttpPostMethod.

private MethodMetadataBuilder getHttpPostMethod(final String declaredByMetadataId) {
    final List<AnnotationMetadataBuilder> postMethodAnnotations = new ArrayList<AnnotationMetadataBuilder>();
    final List<AnnotationAttributeValue<?>> postMethodAttributes = new ArrayList<AnnotationAttributeValue<?>>();
    postMethodAttributes.add(new EnumAttributeValue(new JavaSymbolName("method"), new EnumDetails(REQUEST_METHOD, new JavaSymbolName("POST"))));
    postMethodAttributes.add(new StringAttributeValue(new JavaSymbolName("value"), "{id}"));
    postMethodAnnotations.add(new AnnotationMetadataBuilder(REQUEST_MAPPING, postMethodAttributes));
    final List<AnnotatedJavaType> postParamTypes = new ArrayList<AnnotatedJavaType>();
    final AnnotationMetadataBuilder idParamAnnotation = new AnnotationMetadataBuilder(PATH_VARIABLE);
    postParamTypes.add(new AnnotatedJavaType(new JavaType("java.lang.Long"), idParamAnnotation.build()));
    postParamTypes.add(new AnnotatedJavaType(MODEL_MAP));
    postParamTypes.add(new AnnotatedJavaType(HTTP_SERVLET_REQUEST));
    postParamTypes.add(new AnnotatedJavaType(HTTP_SERVLET_RESPONSE));
    final List<JavaSymbolName> postParamNames = new ArrayList<JavaSymbolName>();
    postParamNames.add(new JavaSymbolName("id"));
    postParamNames.add(new JavaSymbolName("modelMap"));
    postParamNames.add(new JavaSymbolName("request"));
    postParamNames.add(new JavaSymbolName("response"));
    final MethodMetadataBuilder postMethodBuilder = new MethodMetadataBuilder(declaredByMetadataId, Modifier.PUBLIC, new JavaSymbolName("post"), JavaType.VOID_PRIMITIVE, postParamTypes, postParamNames, new InvocableMemberBodyBuilder());
    postMethodBuilder.setAnnotations(postMethodAnnotations);
    return postMethodBuilder;
}

Example 25 with EnumDetails

use of org.springframework.roo.model.EnumDetails in project spring-roo by spring-projects.

the class WebFinderOperationsImpl method buildNewSearchController.

/**
 * Build a new search controller for provided entity, with provided response type,
 * package, path prefix and query methods.
 *
 * @param entity
 * @param queryMethods
 * @param responseType
 * @param controllerPackage
 * @param pathPrefix
 * @return
 */
private ClassOrInterfaceTypeDetailsBuilder buildNewSearchController(JavaType entity, List<String> queryMethods, ControllerMVCResponseService responseType, JavaPackage controllerPackage, String pathPrefix) {
    ClassOrInterfaceTypeDetailsBuilder controllerBuilder;
    JavaType searchController = new JavaType(String.format("%s.%sSearch%sController", controllerPackage.getFullyQualifiedPackageName(), pluralService.getPlural(entity), responseType.getControllerNameModifier()), controllerPackage.getModule());
    final String physicalPath = PhysicalTypeIdentifier.createIdentifier(searchController, LogicalPath.getInstance(Path.SRC_MAIN_JAVA, controllerPackage.getModule()));
    controllerBuilder = new ClassOrInterfaceTypeDetailsBuilder(physicalPath, Modifier.PUBLIC, searchController, PhysicalTypeCategory.CLASS);
    // Create @RooController
    AnnotationMetadataBuilder controllerAnnotation = 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());
    // Create @RooSearch
    AnnotationMetadataBuilder searchAnnotation = 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);
    // Add response type annotation
    AnnotationMetadataBuilder responseTypeAnnotation = new AnnotationMetadataBuilder(responseType.getAnnotation());
    controllerBuilder.addAnnotation(responseTypeAnnotation);
    return controllerBuilder;
}