Examples of org.springframework.roo.classpath.details.MethodMetadataBuilder

Package org.springframework.roo.classpath.details

Examples of org.springframework.roo.classpath.details.MethodMetadataBuilder

org.springframework.roo.classpath.details.MethodMetadataBuilder
Builder for {@link MethodMetadata}. @author Ben Alex @since 1.1

        bodyBuilder
                .appendFormalLine("FacesContext.getCurrentInstance().addMessage(null, facesMessage);");
        bodyBuilder.appendFormalLine("reset();");
        bodyBuilder.appendFormalLine("return findAll" + plural + "();");


        return new MethodMetadataBuilder(getId(), PUBLIC, methodName, STRING,
                new ArrayList<AnnotatedJavaType>(),
                new ArrayList<JavaSymbolName>(), bodyBuilder);
    }

View Full Code Here


        if (governorHasMethod(methodName)) {
            return null;
        }


        final MethodMetadataBuilder methodBuilder = new MethodMetadataBuilder(
                getId());
        methodBuilder.setModifier(PUBLIC);
        methodBuilder.setMethodName(methodName);
        methodBuilder.setReturnType(HTML_PANEL_GRID);
        methodBuilder.setParameterTypes(new ArrayList<AnnotatedJavaType>());
        methodBuilder.setParameterNames(new ArrayList<JavaSymbolName>());


        builder.getImportRegistrationResolver().addImports(FACES_CONTEXT,
                HTML_PANEL_GRID);


        final InvocableMemberBodyBuilder bodyBuilder = new InvocableMemberBodyBuilder();
        bodyBuilder
                .appendFormalLine("FacesContext facesContext = FacesContext.getCurrentInstance();");
        bodyBuilder.appendFormalLine(APPLICATION.getFullyQualifiedTypeName()
                + " application = facesContext.getApplication();");


        if (locatedFields.isEmpty()) {
            bodyBuilder.appendFormalLine("return "
                    + getComponentCreation("HtmlPanelGrid"));
            methodBuilder.setBodyBuilder(bodyBuilder);
            return methodBuilder;
        }


        builder.getImportRegistrationResolver().addImports(EL_CONTEXT,
                EXPRESSION_FACTORY, HTML_OUTPUT_TEXT, PRIMEFACES_OUTPUT_LABEL);


        bodyBuilder
                .appendFormalLine("ExpressionFactory expressionFactory = application.getExpressionFactory();");
        bodyBuilder
                .appendFormalLine("ELContext elContext = facesContext.getELContext();");
        bodyBuilder.appendFormalLine("");
        bodyBuilder.appendFormalLine("HtmlPanelGrid " + HTML_PANEL_GRID_ID
                + " = " + getComponentCreation("HtmlPanelGrid"));
        bodyBuilder.appendFormalLine("");


        for (final FieldMetadata field : locatedFields) {
            final CustomData customData = field.getCustomData();
            final JavaType fieldType = field.getFieldType();
            final String simpleTypeName = fieldType.getSimpleTypeName();
            final String fieldName = field.getFieldName().getSymbolName();
            final String fieldLabelId = fieldName + suffix1;
            final String fieldValueId = fieldName + suffix2;


            final BigDecimal minValue = ObjectUtils.max(
                    getMinOrMaxValue(field, MIN),
                    getMinOrMaxValue(field, DECIMAL_MIN));


            final BigDecimal maxValue = ObjectUtils.min(
                    getMinOrMaxValue(field, MAX),
                    getMinOrMaxValue(field, DECIMAL_MAX));


            final Integer sizeMinValue = getSizeMinOrMax(field, "min");


            final Integer min = ObjectUtils.min(getSizeMinOrMax(field, "max"),
                    getColumnLength(field));
            final BigDecimal sizeMaxValue = min != null ? new BigDecimal(min)
                    : null;


            final boolean required = action != Action.VIEW
                    && (!isNullable(field) || minValue != null
                            || maxValue != null || sizeMinValue != null || sizeMaxValue != null);
            final boolean isTextarea = sizeMinValue != null
                    && sizeMinValue.intValue() > 30 || sizeMaxValue != null
                    && sizeMaxValue.intValue() > 30
                    || customData.keySet().contains(CustomDataKeys.LOB_FIELD);


            final boolean isUIComponent = isUIComponent(field, fieldType,
                    customData);


            // Field label
            if (action.equals(Action.VIEW) || !isUIComponent) {
                bodyBuilder.appendFormalLine("HtmlOutputText " + fieldLabelId
                        + " = " + getComponentCreation("HtmlOutputText"));
            }
            else {
                bodyBuilder.appendFormalLine("OutputLabel " + fieldLabelId
                        + " = " + getComponentCreation("OutputLabel"));
                bodyBuilder.appendFormalLine(fieldLabelId + ".setFor(\""
                        + fieldValueId + "\");");
            }
            bodyBuilder.appendFormalLine(fieldLabelId + ".setId(\""
                    + fieldLabelId + "\");");
            bodyBuilder.appendFormalLine(fieldLabelId + ".setValue(\""
                    + field.getFieldName().getReadableSymbolName() + ":\");");
            bodyBuilder.appendFormalLine(getAddToPanelText(fieldLabelId));
            bodyBuilder.appendFormalLine("");


            // Field value
            final String converterName = fieldValueId + "Converter";
            final String htmlOutputTextStr = "HtmlOutputText " + fieldValueId
                    + " = " + getComponentCreation("HtmlOutputText");
            final String inputTextStr = "InputText " + fieldValueId + " = "
                    + getComponentCreation("InputText");
            final String componentIdStr = fieldValueId + ".setId(\""
                    + fieldValueId + "\");";
            final String requiredStr = fieldValueId + ".setRequired("
                    + required + ");";


            if (field.getAnnotation(ROO_UPLOADED_FILE) != null) {
                final AnnotationMetadata annotation = field
                        .getAnnotation(ROO_UPLOADED_FILE);
                final String contentType = (String) annotation.getAttribute(
                        "contentType").getValue();
                final String allowedType = UploadedFileContentType
                        .getFileExtension(contentType).name();
                if (action == Action.VIEW) {
                    builder.getImportRegistrationResolver().addImports(
                            UI_COMPONENT,
                            PRIMEFACES_FILE_DOWNLOAD_ACTION_LISTENER,
                            PRIMEFACES_COMMAND_BUTTON,
                            PRIMEFACES_STREAMED_CONTENT);


                    // bodyBuilder.appendFormalLine("CommandButton " +
                    // fieldValueId + " = " +
                    // getComponentCreation("CommandButton"));
                    // bodyBuilder.appendFormalLine(fieldValueId +
                    // ".addActionListener(new FileDownloadActionListener(expressionFactory.createValueExpression(elContext, \"#{"
                    // + beanName + "." +
                    // fieldName +
                    // "StreamedContent}\", StreamedContent.class), null));");
                    // bodyBuilder.appendFormalLine(fieldValueId +
                    // ".setValue(\"Download\");");
                    // bodyBuilder.appendFormalLine(fieldValueId +
                    // ".setAjax(false);");


                    // TODO Make following code work as currently the view panel
                    // is not refreshed and the download field is always seen as
                    // null
                    bodyBuilder.appendFormalLine("UIComponent " + fieldValueId
                            + ";");
                    bodyBuilder.appendFormalLine("if (" + entityName
                            + " != null && " + entityName + ".get"
                            + StringUtils.capitalize(fieldName)
                            + "() != null && " + entityName + ".get"
                            + StringUtils.capitalize(fieldName)
                            + "().length > 0) {");
                    bodyBuilder.indent();
                    bodyBuilder.appendFormalLine(fieldValueId + " = "
                            + getComponentCreation("CommandButton"));
                    bodyBuilder
                            .appendFormalLine("((CommandButton) "
                                    + fieldValueId
                                    + ").addActionListener(new FileDownloadActionListener(expressionFactory.createValueExpression(elContext, \"#{"
                                    + beanName
                                    + "."
                                    + fieldName
                                    + "StreamedContent}\", StreamedContent.class), null));");
                    bodyBuilder.appendFormalLine("((CommandButton) "
                            + fieldValueId + ").setValue(\"Download\");");
                    bodyBuilder.appendFormalLine("((CommandButton) "
                            + fieldValueId + ").setAjax(false);");
                    bodyBuilder.indentRemove();
                    bodyBuilder.appendFormalLine("} else {");
                    bodyBuilder.indent();
                    bodyBuilder.appendFormalLine(fieldValueId + " = "
                            + getComponentCreation("HtmlOutputText"));
                    bodyBuilder.appendFormalLine("((HtmlOutputText) "
                            + fieldValueId + ").setValue(\"\");");
                    bodyBuilder.indentRemove();
                    bodyBuilder.appendFormalLine("}");
                }
                else {
                    builder.getImportRegistrationResolver().addImports(
                            PRIMEFACES_FILE_UPLOAD,
                            PRIMEFACES_FILE_UPLOAD_EVENT);


                    bodyBuilder.appendFormalLine("FileUpload " + fieldValueId
                            + " = " + getComponentCreation("FileUpload"));
                    bodyBuilder.appendFormalLine(componentIdStr);
                    bodyBuilder
                            .appendFormalLine(fieldValueId
                                    + ".setFileUploadListener(expressionFactory.createMethodExpression(elContext, \"#{"
                                    + beanName
                                    + "."
                                    + getFileUploadMethodName(fieldName)
                                    + "}\", void.class, new Class[] { FileUploadEvent.class }));");
                    bodyBuilder.appendFormalLine(fieldValueId
                            + ".setMode(\"advanced\");");
                    bodyBuilder.appendFormalLine(fieldValueId
                            + ".setAllowTypes(\"/(\\\\.|\\\\/)("
                            + getAllowTypeRegex(allowedType) + ")$/\");");
                    bodyBuilder.appendFormalLine(fieldValueId
                            + ".setUpdate(\":growlForm:growl\");");


                    final AnnotationAttributeValue<?> autoUploadAttr = annotation
                            .getAttribute("autoUpload");
                    if (autoUploadAttr != null
                            && (Boolean) autoUploadAttr.getValue()) {
                        bodyBuilder.appendFormalLine(fieldValueId
                                + ".setAuto(true);");
                    }
                    bodyBuilder.appendFormalLine(requiredStr);
                }
            }
            else if (fieldType.equals(BOOLEAN_OBJECT)
                    || fieldType.equals(BOOLEAN_PRIMITIVE)) {
                if (action == Action.VIEW) {
                    bodyBuilder.appendFormalLine(htmlOutputTextStr);
                    bodyBuilder.appendFormalLine(getSetValueExpression(
                            fieldValueId, fieldName));
                }
                else {
                    builder.getImportRegistrationResolver().addImport(
                            PRIMEFACES_SELECT_BOOLEAN_CHECKBOX);
                    bodyBuilder.appendFormalLine("SelectBooleanCheckbox "
                            + fieldValueId + " = "
                            + getComponentCreation("SelectBooleanCheckbox"));
                    bodyBuilder.appendFormalLine(componentIdStr);
                    bodyBuilder.appendFormalLine(getSetValueExpression(
                            fieldValueId, fieldName, simpleTypeName));
                    bodyBuilder.appendFormalLine(requiredStr);
                }
            }
            else if (customData.keySet().contains(ENUMERATED_KEY)) {
                if (action == Action.VIEW) {
                    bodyBuilder.appendFormalLine(htmlOutputTextStr);
                    bodyBuilder.appendFormalLine(getSetValueExpression(
                            fieldValueId, fieldName));
                }
                else {
                    builder.getImportRegistrationResolver().addImports(
                            PRIMEFACES_AUTO_COMPLETE, fieldType);


                    bodyBuilder.appendFormalLine("AutoComplete " + fieldValueId
                            + " = " + getComponentCreation("AutoComplete"));
                    bodyBuilder.appendFormalLine(componentIdStr);
                    bodyBuilder.appendFormalLine(getSetValueExpression(
                            fieldValueId, fieldName, simpleTypeName));
                    bodyBuilder.appendFormalLine(getSetCompleteMethod(
                            fieldValueId, fieldName));
                    bodyBuilder.appendFormalLine(fieldValueId
                            + ".setDropdown(true);");
                    bodyBuilder.appendFormalLine(requiredStr);
                }
            }
            else if (JdkJavaType.isDateField(fieldType)) {
                if (action == Action.VIEW) {
                    builder.getImportRegistrationResolver().addImport(
                            DATE_TIME_CONVERTER);


                    bodyBuilder.appendFormalLine(htmlOutputTextStr);
                    bodyBuilder.appendFormalLine(getSetValueExpression(
                            fieldValueId, fieldName, simpleTypeName));
                    bodyBuilder
                            .appendFormalLine("DateTimeConverter "
                                    + converterName
                                    + " = (DateTimeConverter) application.createConverter(DateTimeConverter.CONVERTER_ID);");
                    // TODO Get working:
                    // bodyBuilder.appendFormalLine(converterName +
                    // ".setPattern(((SimpleDateFormat) DateFormat.getDateInstance(DateFormat.SHORT)).toPattern());");
                    bodyBuilder.appendFormalLine(converterName
                            + ".setPattern(\"dd/MM/yyyy\");");
                    bodyBuilder.appendFormalLine(fieldValueId
                            + ".setConverter(" + converterName + ");");
                }
                else {
                    builder.getImportRegistrationResolver().addImports(
                            PRIMEFACES_CALENDAR, DATE);
                    // builder.getImportRegistrationResolver().addImports(DATE_FORMAT,
                    // SIMPLE_DATE_FORMAT);


                    bodyBuilder.appendFormalLine("Calendar " + fieldValueId
                            + " = " + getComponentCreation("Calendar"));
                    bodyBuilder.appendFormalLine(componentIdStr);
                    bodyBuilder.appendFormalLine(getSetValueExpression(
                            fieldValueId, fieldName, "Date"));
                    bodyBuilder.appendFormalLine(fieldValueId
                            + ".setNavigator(true);");
                    bodyBuilder.appendFormalLine(fieldValueId
                            + ".setEffect(\"slideDown\");");
                    // TODO Get working:
                    // bodyBuilder.appendFormalLine(fieldValueId +
                    // ".setPattern(((SimpleDateFormat) DateFormat.getDateInstance(DateFormat.SHORT)).toPattern());");
                    bodyBuilder.appendFormalLine(fieldValueId
                            + ".setPattern(\"dd/MM/yyyy\");");
                    bodyBuilder.appendFormalLine(requiredStr);
                    if (MemberFindingUtils.getAnnotationOfType(
                            field.getAnnotations(), PAST) != null) {
                        bodyBuilder.appendFormalLine(fieldValueId
                                + ".setMaxdate(new Date());");
                    }
                    if (MemberFindingUtils.getAnnotationOfType(
                            field.getAnnotations(), FUTURE) != null) {
                        bodyBuilder.appendFormalLine(fieldValueId
                                + ".setMindate(new Date());");
                    }
                }
            }
            else if (JdkJavaType.isIntegerType(fieldType)) {
                if (action == Action.VIEW) {
                    bodyBuilder.appendFormalLine(htmlOutputTextStr);
                    bodyBuilder.appendFormalLine(getSetValueExpression(
                            fieldValueId, fieldName));
                }
                else {
                    builder.getImportRegistrationResolver().addImports(
                            PRIMEFACES_INPUT_TEXT, PRIMEFACES_SPINNER);
                    if (fieldType.equals(JdkJavaType.BIG_INTEGER)) {
                        builder.getImportRegistrationResolver().addImport(
                                fieldType);
                    }


                    bodyBuilder.appendFormalLine("Spinner " + fieldValueId
                            + " = " + getComponentCreation("Spinner"));
                    bodyBuilder.appendFormalLine(componentIdStr);
                    bodyBuilder.appendFormalLine(getSetValueExpression(
                            fieldValueId, fieldName, simpleTypeName));
                    bodyBuilder.appendFormalLine(requiredStr);
                    if (minValue != null || maxValue != null) {
                        if (minValue != null) {
                            bodyBuilder.appendFormalLine(fieldValueId
                                    + ".setMin(" + minValue.doubleValue()
                                    + ");");
                        }
                        if (maxValue != null) {
                            bodyBuilder.appendFormalLine(fieldValueId
                                    + ".setMax(" + maxValue.doubleValue()
                                    + ");");
                        }
                        bodyBuilder.append(getLongRangeValdatorString(
                                fieldValueId, minValue, maxValue));
                    }
                    bodyBuilder.appendFormalLine("");
                }
            }
            else if (JdkJavaType.isDecimalType(fieldType)) {
                if (action == Action.VIEW) {
                    bodyBuilder.appendFormalLine(htmlOutputTextStr);
                    bodyBuilder.appendFormalLine(getSetValueExpression(
                            fieldValueId, fieldName));
                }
                else {
                    builder.getImportRegistrationResolver().addImport(
                            PRIMEFACES_INPUT_TEXT);
                    if (fieldType.equals(JdkJavaType.BIG_DECIMAL)) {
                        builder.getImportRegistrationResolver().addImport(
                                fieldType);
                    }


                    bodyBuilder.appendFormalLine(inputTextStr);
                    bodyBuilder.appendFormalLine(componentIdStr);
                    bodyBuilder.appendFormalLine(getSetValueExpression(
                            fieldValueId, fieldName, simpleTypeName));
                    bodyBuilder.appendFormalLine(requiredStr);
                    if (minValue != null || maxValue != null) {
                        bodyBuilder.append(getDoubleRangeValdatorString(
                                fieldValueId, minValue, maxValue));
                    }
                }
            }
            else if (fieldType.equals(STRING)) {
                if (isTextarea) {
                    builder.getImportRegistrationResolver().addImport(
                            PRIMEFACES_INPUT_TEXTAREA);
                    bodyBuilder.appendFormalLine("InputTextarea "
                            + fieldValueId + " = "
                            + getComponentCreation("InputTextarea"));
                }
                else {
                    if (action == Action.VIEW) {
                        bodyBuilder.appendFormalLine(htmlOutputTextStr);
                    }
                    else {
                        builder.getImportRegistrationResolver().addImport(
                                PRIMEFACES_INPUT_TEXT);
                        bodyBuilder.appendFormalLine(inputTextStr);
                    }
                }


                bodyBuilder.appendFormalLine(componentIdStr);
                bodyBuilder.appendFormalLine(getSetValueExpression(
                        fieldValueId, fieldName));
                if (action == Action.VIEW) {
                    if (isTextarea) {
                        bodyBuilder.appendFormalLine(fieldValueId
                                + ".setReadonly(true);");
                        bodyBuilder.appendFormalLine(fieldValueId
                                + ".setDisabled(true);");
                    }
                }
                else {
                    if (sizeMinValue != null || sizeMaxValue != null) {
                        bodyBuilder.append(getLengthValdatorString(
                                fieldValueId, sizeMinValue, sizeMaxValue));
                    }
                    setRegexPatternValidationString(field, fieldValueId,
                            bodyBuilder);
                    bodyBuilder.appendFormalLine(requiredStr);
                }
            }
            else if (customData.keySet().contains(PARAMETER_TYPE_KEY)) {
                final JavaType parameterType = (JavaType) customData
                        .get(PARAMETER_TYPE_KEY);
                final String parameterTypeSimpleTypeName = parameterType
                        .getSimpleTypeName();
                final String parameterTypeFieldName = StringUtils
                        .uncapitalize(parameterTypeSimpleTypeName);
                final String parameterTypeManagedBeanName = (String) customData
                        .get(PARAMETER_TYPE_MANAGED_BEAN_NAME_KEY);
                final String parameterTypePlural = (String) customData
                        .get(PARAMETER_TYPE_PLURAL_KEY);


                if (StringUtils.isNotBlank(parameterTypeManagedBeanName)) {
                    if (customData.keySet().contains(ONE_TO_MANY_FIELD)
                            || customData.keySet().contains(MANY_TO_MANY_FIELD)
                            && isInverseSideOfRelationship(field, ONE_TO_MANY,
                                    MANY_TO_MANY)) {
                        bodyBuilder.appendFormalLine(htmlOutputTextStr);
                        bodyBuilder.appendFormalLine(componentIdStr);
                        bodyBuilder
                                .appendFormalLine(fieldValueId
                                        + ".setValue(\"This relationship is managed from the "
                                        + parameterTypeSimpleTypeName
                                        + " side\");");
                    }
                    else {
                        final JavaType converterType = new JavaType(destination
                                .getPackage().getFullyQualifiedPackageName()
                                + ".converter."
                                + parameterTypeSimpleTypeName
                                + "Converter");
                        builder.getImportRegistrationResolver().addImports(
                                PRIMEFACES_SELECT_MANY_MENU, UI_SELECT_ITEMS,
                                fieldType, converterType);


                        bodyBuilder.appendFormalLine("SelectManyMenu "
                                + fieldValueId + " = "
                                + getComponentCreation("SelectManyMenu"));
                        bodyBuilder.appendFormalLine(componentIdStr);
                        bodyBuilder.appendFormalLine(fieldValueId
                                + ".setConverter(new "
                                + converterType.getSimpleTypeName() + "());");
                        bodyBuilder
                                .appendFormalLine(fieldValueId
                                        + ".setValueExpression(\"value\", expressionFactory.createValueExpression(elContext, \"#{"
                                        + beanName + "."
                                        + getSelectedFieldName(fieldName)
                                        + "}\", List.class));");
                        bodyBuilder
                                .appendFormalLine("UISelectItems "
                                        + fieldValueId
                                        + "Items = (UISelectItems) application.createComponent(UISelectItems.COMPONENT_TYPE);");
                        if (action == Action.VIEW) {
                            bodyBuilder.appendFormalLine(fieldValueId
                                    + ".setReadonly(true);");
                            bodyBuilder.appendFormalLine(fieldValueId
                                    + ".setDisabled(true);");
                            bodyBuilder
                                    .appendFormalLine(fieldValueId
                                            + "Items.setValueExpression(\"value\", expressionFactory.createValueExpression(elContext, \"#{"
                                            + beanName + "."
                                            + entityName.getSymbolName() + "."
                                            + fieldName + "}\", "
                                            + simpleTypeName + ".class));");
                        }
                        else {
                            bodyBuilder
                                    .appendFormalLine(fieldValueId
                                            + "Items.setValueExpression(\"value\", expressionFactory.createValueExpression(elContext, \"#{"
                                            + parameterTypeManagedBeanName
                                            + ".all"
                                            + StringUtils
                                                    .capitalize(parameterTypePlural)
                                            + "}\", List.class));");
                            bodyBuilder.appendFormalLine(requiredStr);
                        }
                        bodyBuilder
                                .appendFormalLine(fieldValueId
                                        + "Items.setValueExpression(\"var\", expressionFactory.createValueExpression(elContext, \""
                                        + parameterTypeFieldName
                                        + "\", String.class));");
                        bodyBuilder
                                .appendFormalLine(fieldValueId
                                        + "Items.setValueExpression(\"itemLabel\", expressionFactory.createValueExpression(elContext, \"#{"
                                        + parameterTypeFieldName
                                        + "}\", String.class));");
                        bodyBuilder
                                .appendFormalLine(fieldValueId
                                        + "Items.setValueExpression(\"itemValue\", expressionFactory.createValueExpression(elContext, \"#{"
                                        + parameterTypeFieldName + "}\", "
                                        + parameterTypeSimpleTypeName
                                        + ".class));");
                        bodyBuilder.appendFormalLine(getAddChildToComponent(
                                fieldValueId, fieldValueId + "Items"));
                    }
                }
                else {
                    // Parameter type is an enum
                    bodyBuilder.appendFormalLine("SelectManyMenu "
                            + fieldValueId + " = "
                            + getComponentCreation("SelectManyMenu"));
                    bodyBuilder.appendFormalLine(componentIdStr);
                    if (action == Action.VIEW) {
                        bodyBuilder.appendFormalLine(fieldValueId
                                + ".setReadonly(true);");
                        bodyBuilder.appendFormalLine(fieldValueId
                                + ".setDisabled(true);");
                        bodyBuilder
                                .appendFormalLine(fieldValueId
                                        + ".setValueExpression(\"value\", expressionFactory.createValueExpression(elContext, \"#{"
                                        + beanName + "."
                                        + getSelectedFieldName(fieldName)
                                        + "}\", List.class));");
                        bodyBuilder
                                .appendFormalLine("UISelectItems "
                                        + fieldValueId
                                        + "Items = (UISelectItems) application.createComponent(UISelectItems.COMPONENT_TYPE);");
                        bodyBuilder
                                .appendFormalLine(fieldValueId
                                        + "Items.setValueExpression(\"value\", expressionFactory.createValueExpression(elContext, \"#{"
                                        + beanName + "."
                                        + entityName.getSymbolName() + "."
                                        + fieldName + "}\", " + simpleTypeName
                                        + ".class));");
                        bodyBuilder
                                .appendFormalLine(fieldValueId
                                        + "Items.setValueExpression(\"var\", expressionFactory.createValueExpression(elContext, \""
                                        + parameterTypeFieldName
                                        + "\", String.class));");
                        bodyBuilder
                                .appendFormalLine(fieldValueId
                                        + "Items.setValueExpression(\"itemLabel\", expressionFactory.createValueExpression(elContext, \"#{"
                                        + parameterTypeFieldName
                                        + "}\", String.class));");
                        bodyBuilder
                                .appendFormalLine(fieldValueId
                                        + "Items.setValueExpression(\"itemValue\", expressionFactory.createValueExpression(elContext, \"#{"
                                        + parameterTypeFieldName + "}\", "
                                        + parameterTypeSimpleTypeName
                                        + ".class));");
                        bodyBuilder.appendFormalLine(getAddChildToComponent(
                                fieldValueId, fieldValueId + "Items"));
                    }
                    else {
                        builder.getImportRegistrationResolver().addImports(
                                UI_SELECT_ITEM, ENUM_CONVERTER);


                        bodyBuilder
                                .appendFormalLine(fieldValueId
                                        + ".setValueExpression(\"value\", expressionFactory.createValueExpression(elContext, \"#{"
                                        + beanName + "."
                                        + getSelectedFieldName(fieldName)
                                        + "}\", List.class));");
                        bodyBuilder.appendFormalLine(fieldValueId
                                + ".setConverter(new EnumConverter("
                                + parameterTypeSimpleTypeName + ".class));");
                        bodyBuilder.appendFormalLine(requiredStr);
                        bodyBuilder.appendFormalLine("UISelectItem "
                                + fieldValueId + "Item;");
                        bodyBuilder
                                .appendFormalLine("for ("
                                        + parameterTypeSimpleTypeName
                                        + " "
                                        + StringUtils
                                                .uncapitalize(parameterTypeSimpleTypeName)
                                        + " : " + parameterTypeSimpleTypeName
                                        + ".values()) {");
                        bodyBuilder.indent();
                        bodyBuilder
                                .appendFormalLine(fieldValueId
                                        + "Item = (UISelectItem) application.createComponent(UISelectItem.COMPONENT_TYPE);");
                        bodyBuilder
                                .appendFormalLine(fieldValueId
                                        + "Item.setItemLabel("
                                        + StringUtils
                                                .uncapitalize(parameterTypeSimpleTypeName)
                                        + ".name());");
                        bodyBuilder
                                .appendFormalLine(fieldValueId
                                        + "Item.setItemValue("
                                        + StringUtils
                                                .uncapitalize(parameterTypeSimpleTypeName)
                                        + ");");
                        bodyBuilder.appendFormalLine(getAddChildToComponent(
                                fieldValueId, fieldValueId + "Item"));
                        bodyBuilder.indentRemove();
                        bodyBuilder.appendFormalLine("}");
                    }
                }
            }
            else if (customData.keySet().contains(APPLICATION_TYPE_KEY)) {
                if (customData.keySet().contains(ONE_TO_ONE_FIELD)
                        && isInverseSideOfRelationship(field, ONE_TO_ONE)) {
                    bodyBuilder.appendFormalLine(htmlOutputTextStr);
                    bodyBuilder.appendFormalLine(componentIdStr);
                    bodyBuilder
                            .appendFormalLine(fieldValueId
                                    + ".setValue(\"This relationship is managed from the "
                                    + simpleTypeName + " side\");");
                }
                else {
                    final JavaType converterType = new JavaType(destination
                            .getPackage().getFullyQualifiedPackageName()
                            + ".converter." + simpleTypeName + "Converter");
                    builder.getImportRegistrationResolver().addImport(
                            converterType);
                    if (action == Action.VIEW) {
                        bodyBuilder.appendFormalLine(htmlOutputTextStr);
                        bodyBuilder.appendFormalLine(getSetValueExpression(
                                fieldValueId, fieldName, simpleTypeName));
                        bodyBuilder.appendFormalLine(fieldValueId
                                + ".setConverter(new "
                                + converterType.getSimpleTypeName() + "());");
                    }
                    else {
                        builder.getImportRegistrationResolver().addImports(
                                PRIMEFACES_AUTO_COMPLETE, fieldType);


                        bodyBuilder.appendFormalLine("AutoComplete "
                                + fieldValueId + " = "
                                + getComponentCreation("AutoComplete"));
                        bodyBuilder.appendFormalLine(componentIdStr);
                        bodyBuilder.appendFormalLine(getSetValueExpression(
                                fieldValueId, fieldName, simpleTypeName));
                        bodyBuilder.appendFormalLine(getSetCompleteMethod(
                                fieldValueId, fieldName));
                        bodyBuilder.appendFormalLine(fieldValueId
                                + ".setDropdown(true);");
                        bodyBuilder
                                .appendFormalLine(fieldValueId
                                        + ".setValueExpression(\"var\", expressionFactory.createValueExpression(elContext, \""
                                        + fieldName + "\", String.class));");
                        bodyBuilder
                                .appendFormalLine(fieldValueId
                                        + ".setValueExpression(\"itemLabel\", expressionFactory.createValueExpression(elContext, \""
                                        + getAutoCcompleteItemLabelValue(field,
                                                fieldName)
                                        + "\", String.class));");
                        bodyBuilder
                                .appendFormalLine(fieldValueId
                                        + ".setValueExpression(\"itemValue\", expressionFactory.createValueExpression(elContext, \"#{"
                                        + fieldName + "}\", " + simpleTypeName
                                        + ".class));");
                        bodyBuilder.appendFormalLine(fieldValueId
                                + ".setConverter(new "
                                + converterType.getSimpleTypeName() + "());");
                        bodyBuilder.appendFormalLine(requiredStr);
                    }
                }
            }
            else {
                if (action == Action.VIEW) {
                    bodyBuilder.appendFormalLine(htmlOutputTextStr);
                    bodyBuilder.appendFormalLine(getSetValueExpression(
                            fieldValueId, fieldName));
                }
                else {
                    builder.getImportRegistrationResolver().addImport(
                            PRIMEFACES_INPUT_TEXT);


                    bodyBuilder.appendFormalLine(inputTextStr);
                    bodyBuilder.appendFormalLine(componentIdStr);
                    bodyBuilder.appendFormalLine(getSetValueExpression(
                            fieldValueId, fieldName, simpleTypeName));
                    bodyBuilder.appendFormalLine(requiredStr);
                }
            }


            if (action != Action.VIEW) {
                bodyBuilder.appendFormalLine(getAddToPanelText(fieldValueId));
                // Add message for input field
                builder.getImportRegistrationResolver().addImport(
                        PRIMEFACES_MESSAGE);


                bodyBuilder.appendFormalLine("");
                bodyBuilder.appendFormalLine("Message " + fieldValueId
                        + "Message = " + getComponentCreation("Message"));
                bodyBuilder.appendFormalLine(fieldValueId + "Message.setId(\""
                        + fieldValueId + "Message\");");
                bodyBuilder.appendFormalLine(fieldValueId + "Message.setFor(\""
                        + fieldValueId + "\");");
                bodyBuilder.appendFormalLine(fieldValueId
                        + "Message.setDisplay(\"icon\");");
                bodyBuilder.appendFormalLine(getAddToPanelText(fieldValueId
                        + "Message"));
            }
            else {
                bodyBuilder.appendFormalLine(getAddToPanelText(fieldValueId));
            }


            bodyBuilder.appendFormalLine("");
        }
        bodyBuilder.appendFormalLine("return " + HTML_PANEL_GRID_ID + ";");


        return new MethodMetadataBuilder(getId(), PUBLIC, methodName,
                HTML_PANEL_GRID, new ArrayList<AnnotatedJavaType>(),
                new ArrayList<JavaSymbolName>(), bodyBuilder);
    }

View Full Code Here

                        method.getParameterTypes(domainType, idType), getId())) {
            // We don't want this method, or the governor already declares it
            return null;
        }


        return new MethodMetadataBuilder(getId(), PUBLIC_ABSTRACT, methodName,
                method.getReturnType(domainType),
                AnnotatedJavaType.convertFromJavaTypes(method
                        .getParameterTypes(domainType, idType)),
                method.getParameterNames(domainType, idType), BODY);
    }

View Full Code Here

                parameterTypes);
        if (userMethod != null) {
            Validate.isTrue(userMethod.getReturnType().equals(returnType),
                    "Method '%s' on '%s' must return '%s'", methodName,
                    destination, returnType.getNameIncludingTypeParameters());
            return new MethodMetadataBuilder(userMethod);
        }


        final List<JavaSymbolName> parameterNames = new ArrayList<JavaSymbolName>();


        final InvocableMemberBodyBuilder bodyBuilder = new InvocableMemberBodyBuilder();
        bodyBuilder.appendFormalLine("Object obj = getValue();");
        bodyBuilder.appendFormalLine("if (obj == null) {");
        bodyBuilder.indent();
        bodyBuilder.appendFormalLine("return null;");
        bodyBuilder.indentRemove();
        bodyBuilder.appendFormalLine("}");
        bodyBuilder
                .appendFormalLine("return (String) typeConverter.convertIfNecessary((("
                        + javaType.getNameIncludingTypeParameters(false,
                                builder.getImportRegistrationResolver())
                        + ") obj)."
                        + identifierAccessorMethod.getMethodName()
                        + "(), String.class);");


        return new MethodMetadataBuilder(getId(), Modifier.PUBLIC, methodName,
                returnType,
                AnnotatedJavaType.convertFromJavaTypes(parameterTypes),
                parameterNames, bodyBuilder);
    }

View Full Code Here

                parameterType);
        if (userMethod != null) {
            Validate.isTrue(userMethod.getReturnType().equals(returnType),
                    "Method '%s' on '%s' must return '%s'", methodName,
                    destination, returnType.getNameIncludingTypeParameters());
            return new MethodMetadataBuilder(userMethod);
        }


        final String identifierTypeName = idType
                .getNameIncludingTypeParameters(false,
                        builder.getImportRegistrationResolver());


        final InvocableMemberBodyBuilder bodyBuilder = new InvocableMemberBodyBuilder();
        bodyBuilder
                .appendFormalLine("if (text == null || 0 == text.length()) {");
        bodyBuilder.indent();
        bodyBuilder.appendFormalLine("setValue(null);");
        bodyBuilder.appendFormalLine("return;");
        bodyBuilder.indentRemove();
        bodyBuilder.appendFormalLine("}");
        bodyBuilder.newLine();
        bodyBuilder.appendFormalLine(identifierTypeName + " identifier = ("
                + identifierTypeName
                + ") typeConverter.convertIfNecessary(text, "
                + identifierTypeName + ".class);");
        bodyBuilder.appendFormalLine("if (identifier == null) {");
        bodyBuilder.indent();
        bodyBuilder.appendFormalLine("setValue(null);");
        bodyBuilder.appendFormalLine("return;");
        bodyBuilder.indentRemove();
        bodyBuilder.appendFormalLine("}");
        bodyBuilder.newLine();
        bodyBuilder.appendFormalLine("setValue("
                + javaType.getNameIncludingTypeParameters(false,
                        builder.getImportRegistrationResolver()) + "."
                + findMethod.getMethodName() + "(identifier));");


        return new MethodMetadataBuilder(getId(), Modifier.PUBLIC, methodName,
                returnType,
                AnnotatedJavaType.convertFromJavaTypes(parameterType),
                parameterNames, bodyBuilder);
    }

View Full Code Here


    final List<JavaSymbolName> parameterNames = Arrays
        .asList(new JavaSymbolName("registry"));
    builder.getImportRegistrationResolver().addImport(parameterType);


    return new MethodMetadataBuilder(getId(), Modifier.PUBLIC,
        INSTALL_EMBEDDABLE_CONVERTERS, JavaType.VOID_PRIMITIVE,
        AnnotatedJavaType.convertFromJavaTypes(parameterType),
        parameterNames, bodyBuilder);


  }

View Full Code Here

        + "(getObject());");
    if (!this.embeddableTypes.isEmpty()) {
      bodyBuilder.appendFormalLine(INSTALL_EMBEDDABLE_CONVERTERS
          .getSymbolName() + "(getObject());");
    }
    return new MethodMetadataBuilder(getId(), Modifier.PUBLIC, methodName,
        JavaType.VOID_PRIMITIVE, bodyBuilder);
  }

View Full Code Here

      bodyBuilder.appendFormalLine("registry.addConverter("
          + toIdMethodName.getSymbolName() + "());");


      final JavaSymbolName toTypeMethodName = new JavaSymbolName(
          "getIdTo" + simpleName + CONVERTER);
      final MethodMetadataBuilder toTypeConverterMethod = getToTypeConverterMethod(
          formBackingObject, toTypeMethodName,
          findMethods.get(formBackingObject),
          idTypes.get(formBackingObject));
      if (toTypeConverterMethod != null) {
        builder.addMethod(toTypeConverterMethod);
        bodyBuilder.appendFormalLine("registry.addConverter("
            + toTypeMethodName.getSymbolName() + "());");
      }


      // Only allow conversion if ID type is not String already.
      if (!idTypes.get(formBackingObject).equals(JavaType.STRING)) {
        final JavaSymbolName stringToTypeMethodName = new JavaSymbolName(
            "getStringTo" + simpleName + CONVERTER);
        builder.addMethod(getStringToTypeConverterMethod(
            formBackingObject, stringToTypeMethodName,
            idTypes.get(formBackingObject)));
        bodyBuilder.appendFormalLine("registry.addConverter("
            + stringToTypeMethodName.getSymbolName() + "());");
      }
    }


    for (final Entry<JavaType, Map<Object, JavaSymbolName>> entry : compositePrimaryKeyTypes
        .entrySet()) {
      final JavaType targetType = entry.getKey();
      final Map<Object, JavaSymbolName> jsonMethodNames = entry
          .getValue();


      final MethodMetadataBuilder jsonToConverterMethod = getJsonToConverterMethod(
          targetType,
          jsonMethodNames.get(CustomDataJsonTags.FROM_JSON_METHOD));
      if (jsonToConverterMethod != null) {
        builder.addMethod(jsonToConverterMethod);
        bodyBuilder.appendFormalLine("registry.addConverter("
            + jsonToConverterMethod.getMethodName().getSymbolName()
            + "());");
      }


      final MethodMetadataBuilder toJsonConverterMethod = getToJsonConverterMethod(
          targetType,
          jsonMethodNames.get(CustomDataJsonTags.TO_JSON_METHOD));
      if (toJsonConverterMethod != null) {
        builder.addMethod(toJsonConverterMethod);
        bodyBuilder.appendFormalLine("registry.addConverter("
            + toJsonConverterMethod.getMethodName().getSymbolName()
            + "());");
      }
    }


    final JavaType parameterType = FORMATTER_REGISTRY;
    if (governorHasMethod(INSTALL_LABEL_CONVERTERS, parameterType)) {
      return null;
    }


    final List<JavaSymbolName> parameterNames = Arrays
        .asList(new JavaSymbolName("registry"));
    builder.getImportRegistrationResolver().addImport(parameterType);


    return new MethodMetadataBuilder(getId(), Modifier.PUBLIC,
        INSTALL_LABEL_CONVERTERS, JavaType.VOID_PRIMITIVE,
        AnnotatedJavaType.convertFromJavaTypes(parameterType),
        parameterNames, bodyBuilder);
  }

View Full Code Here

    bodyBuilder.indentRemove();
    bodyBuilder.appendFormalLine("}");
    bodyBuilder.indentRemove();
    bodyBuilder.appendFormalLine("};");


    return new MethodMetadataBuilder(getId(), Modifier.PUBLIC, methodName,
        converterJavaType, bodyBuilder);
  }

View Full Code Here

    bodyBuilder.indentRemove();
    bodyBuilder.appendFormalLine("}");
    bodyBuilder.indentRemove();
    bodyBuilder.appendFormalLine("};");


    return new MethodMetadataBuilder(getId(), Modifier.PUBLIC, methodName,
        converterJavaType, bodyBuilder);
  }

View Full Code Here

0 1 2 3 4 5 6 7 8 9

TOP

Related Classes of org.springframework.roo.classpath.details.MethodMetadataBuilder

org.apache.commons.lang3.builder.ToStringBuilder

org.springframework.roo.addon.dod.DataOnDemandMetadata

org.springframework.roo.addon.email.MailOperationsImpl

org.springframework.roo.addon.equals.EqualsMetadata

org.springframework.roo.addon.finder.FinderMetadata

org.springframework.roo.addon.gwt.GwtTypeServiceImpl

org.springframework.roo.addon.gwt.locator.GwtLocatorMetadataProviderImpl

org.springframework.roo.addon.gwt.proxy.GwtProxyMetadataProviderImpl

org.springframework.roo.addon.gwt.request.GwtRequestMetadataProviderImpl

org.springframework.roo.addon.javabean.JavaBeanMetadata

All source code are property of their respective owners. Java is a trademark of Sun Microsystems, Inc and owned by ORACLE Inc. Contact coftware#gmail.com.