Examples with TextBoxItem org.jboss.hal.ballroom.form.TextBoxItem used on opensource projects

Example 6 with TextBoxItem

use of org.jboss.hal.ballroom.form.TextBoxItem in project console by hal.

the class RestResourcePreview method specifyParameters.

private void specifyParameters(String serverUrl, String link, List<String> params) {
    ModelNodeForm.Builder<ModelNode> builder = new ModelNodeForm.Builder<>(Ids.REST_RESOURCE_PATH_PARAM_FORM, Metadata.empty()).addOnly().onSave((form, changedValues) -> {
        String withValues = link;
        for (String param : params) {
            String value = form.<String>getFormItem(param).getValue();
            withValues = withValues.replace("{" + param + "}", value);
        }
        window.open(serverUrl + withValues, serverId());
    });
    int i = 0;
    for (String param : params) {
        FormItem<String> formItem = new TextBoxItem(param, param);
        formItem.setRequired(true);
        builder.unboundFormItem(formItem, i);
        i++;
    }
    Form<ModelNode> form = builder.build();
    Dialog dialog = new Dialog.Builder(resources.constants().specifyParameters()).add(p().innerHtml(resources.messages().specifyParameters(link)).element()).add(form.element()).primary(resources.constants().ok(), form::save).cancel().closeOnEsc(true).closeIcon(true).build();
    dialog.registerAttachable(form);
    dialog.show();
    form.edit(new ModelNode());
}

Example 7 with TextBoxItem

use of org.jboss.hal.ballroom.form.TextBoxItem in project console by hal.

the class ConstantHeadersElement method addConstantHeaderPath.

private void addConstantHeaderPath(Metadata metadata) {
    LabelBuilder labelBuilder = new LabelBuilder();
    String type = labelBuilder.label(PATH);
    TextBoxItem headerName = new TextBoxItem(HEADER_NAME);
    headerName.setRequired(true);
    TextBoxItem headerValue = new TextBoxItem(HEADER_VALUE);
    headerValue.setRequired(true);
    Form<ModelNode> form = new ModelNodeForm.Builder<>(Ids.build(Ids.CONSTANT_HEADERS, Ids.ADD), metadata).addOnly().include(PATH).exclude(HEADERS).dontVerifyExcludes().unboundFormItem(headerName).unboundFormItem(headerValue).build();
    AddResourceDialog dialog = new AddResourceDialog(resources.messages().addResourceTitle(type), form, (name, model) -> {
        if (model != null) {
            ModelNode header = new ModelNode();
            header.get(NAME).set(String.valueOf(form.getFormItem(HEADER_NAME).getValue()));
            header.get(VALUE).set(String.valueOf(form.getFormItem(HEADER_VALUE).getValue()));
            model.get(HEADERS).add(header);
            String finiWasHere = model.get(PATH).asString();
            SafeHtml message = resources.messages().addSuccess(type, finiWasHere, labelBuilder.label(CONSTANT_HEADERS));
            presenter.addConstantHeaderPath(model, message);
        }
    });
    dialog.show();
}

Example 8 with TextBoxItem

use of org.jboss.hal.ballroom.form.TextBoxItem in project console by hal.

the class ServerPresenter method disableSsl.

void disableSsl(String httpsListener) {
    AddressTemplate httpsTemplate = SERVER_TEMPLATE.append(HTTPS_LISTENER + EQ_WILDCARD);
    Metadata metadata = metadataRegistry.lookup(httpsTemplate);
    SafeHtml description = resources.messages().disableSSLUndertowQuestion(httpsListener);
    String label = new LabelBuilder().label(SECURITY_REALM);
    TextBoxItem securityRealmItem = new TextBoxItem(SECURITY_REALM, label);
    securityRealmItem.setRequired(true);
    SafeHtml securityRealmDescription = SafeHtmlUtils.fromTrustedString(metadata.getDescription().get(ATTRIBUTES).get(SECURITY_REALM).get(DESCRIPTION).asString());
    Form<ModelNode> form = new ModelNodeForm.Builder<>(Ids.build(SECURITY_REALM, Ids.FORM), Metadata.empty()).unboundFormItem(securityRealmItem, 0, securityRealmDescription).build();
    HTMLElement content = div().add(p().innerHtml(description)).add(form.element()).element();
    Dialog dialog = new Dialog.Builder(resources.constants().disableSSL()).size(Dialog.Size.MEDIUM).primary(resources.constants().yes(), () -> {
        boolean valid = form.save();
        // if the form contains validation error, don't close the dialog
        if (valid) {
            ResourceAddress httpsAddress = httpsTemplate.resolve(statementContext, serverName, httpsListener);
            Operation undefineSslCtx = new Operation.Builder(httpsAddress, UNDEFINE_ATTRIBUTE_OPERATION).param(NAME, SSL_CONTEXT).build();
            Operation writeSecurityRealm = new Operation.Builder(httpsAddress, WRITE_ATTRIBUTE_OPERATION).param(NAME, SECURITY_REALM).param(VALUE, securityRealmItem.getValue()).build();
            Composite composite = new Composite();
            composite.add(undefineSslCtx);
            composite.add(writeSecurityRealm);
            dispatcher.execute(composite, (CompositeResult result) -> {
                MessageEvent.fire(getEventBus(), Message.success(resources.messages().disableSSLUndertowSuccess(httpsListener)));
                reload();
            }, (operation, failure) -> {
                MessageEvent.fire(getEventBus(), Message.error(resources.messages().disableSSLUndertowError(httpsListener, failure)));
            }, (operation, exception) -> {
                SafeHtml message = resources.messages().disableSSLUndertowError(httpsListener, exception.getMessage());
                MessageEvent.fire(getEventBus(), Message.error(message));
            });
        }
        return valid;
    }).secondary(resources.constants().no(), () -> true).closeIcon(true).closeOnEsc(true).add(content).build();
    dialog.registerAttachable(form);
    dialog.show();
    ModelNode model = new ModelNode().setEmptyObject();
    form.edit(model);
}

Example 9 with TextBoxItem

use of org.jboss.hal.ballroom.form.TextBoxItem in project console by hal.

the class DefaultFormItemProvider method createFrom.

@Override
public FormItem<?> createFrom(Property property) {
    FormItem<?> formItem = null;
    String name = property.getName();
    String label = labelBuilder.label(property);
    ModelNode attributeDescription = property.getValue();
    // don't use 'required' here!
    boolean required = attributeDescription.hasDefined(NILLABLE) && !attributeDescription.get(NILLABLE).asBoolean();
    boolean expressionAllowed = attributeDescription.hasDefined(EXPRESSIONS_ALLOWED) && attributeDescription.get(EXPRESSIONS_ALLOWED).asBoolean();
    boolean readOnly = attributeDescription.hasDefined(ACCESS_TYPE) && (READ_ONLY.equals(attributeDescription.get(ACCESS_TYPE).asString()) || METRIC.equals(attributeDescription.get(ACCESS_TYPE).asString()));
    String unit = attributeDescription.hasDefined(UNIT) ? attributeDescription.get(UNIT).asString() : null;
    Deprecation deprecation = attributeDescription.hasDefined(DEPRECATED) ? new Deprecation(attributeDescription.get(DEPRECATED)) : null;
    if (attributeDescription.hasDefined(TYPE)) {
        ModelType type = attributeDescription.get(TYPE).asType();
        ModelType valueType = (attributeDescription.has(VALUE_TYPE) && attributeDescription.get(VALUE_TYPE).getType() != ModelType.OBJECT) ? ModelType.valueOf(attributeDescription.get(VALUE_TYPE).asString()) : null;
        switch(type) {
            case BOOLEAN:
                {
                    SwitchItem switchItem = new SwitchItem(name, label);
                    if (attributeDescription.hasDefined(DEFAULT)) {
                        switchItem.assignDefaultValue(attributeDescription.get(DEFAULT).asBoolean());
                    }
                    formItem = switchItem;
                    break;
                }
            case BIG_INTEGER:
            case INT:
            case LONG:
                {
                    long min, max;
                    if (type == ModelType.INT) {
                        min = attributeDescription.get(MIN).asLong(Integer.MIN_VALUE);
                        max = attributeDescription.get(MAX).asLong(Integer.MAX_VALUE);
                    } else {
                        min = attributeDescription.get(MIN).asLong(MIN_SAFE_LONG);
                        max = attributeDescription.get(MAX).asLong(MAX_SAFE_LONG);
                    }
                    NumberItem numberItem = new NumberItem(name, label, unit, min, max);
                    if (attributeDescription.hasDefined(DEFAULT)) {
                        long defaultValue = attributeDescription.get(DEFAULT).asLong();
                        numberItem.assignDefaultValue(defaultValue);
                    }
                    formItem = numberItem;
                    break;
                }
            case DOUBLE:
                {
                    long min = attributeDescription.get(MIN).asLong(MIN_SAFE_LONG);
                    long max = attributeDescription.get(MAX).asLong(MAX_SAFE_LONG);
                    NumberDoubleItem numberItem = new NumberDoubleItem(name, label, unit, min, max);
                    if (attributeDescription.hasDefined(DEFAULT)) {
                        double defaultValue = attributeDescription.get(DEFAULT).asDouble();
                        numberItem.assignDefaultValue(defaultValue);
                    }
                    formItem = numberItem;
                    break;
                }
            case LIST:
                {
                    if (valueType != null && ModelType.STRING == valueType) {
                        List<String> allowedValues = stringValues(attributeDescription, ALLOWED);
                        if (!allowedValues.isEmpty()) {
                            MultiSelectBoxItem multiSelectBoxItem = new MultiSelectBoxItem(name, label, allowedValues);
                            if (attributeDescription.hasDefined(DEFAULT)) {
                                List<String> defaultValues = stringValues(attributeDescription, DEFAULT);
                                if (!defaultValues.isEmpty()) {
                                    multiSelectBoxItem.assignDefaultValue(defaultValues);
                                }
                            }
                            formItem = multiSelectBoxItem;
                        } else {
                            ListItem listItem = new ListItem(name, label);
                            if (attributeDescription.hasDefined(DEFAULT)) {
                                List<String> defaultValues = stringValues(attributeDescription, DEFAULT);
                                if (!defaultValues.isEmpty()) {
                                    listItem.assignDefaultValue(defaultValues);
                                }
                            }
                            formItem = listItem;
                            checkCapabilityReference(attributeDescription, formItem);
                        }
                    } else if (isSimpleTuple(attributeDescription)) {
                        // process OBJECT type attribute if all of its subattributes are simple types
                        formItem = new TuplesListItem(name, label, metadata.forComplexAttribute(property.getName()));
                    } else {
                        logger.warn("Unsupported model type {} for attribute {} in metadata {}. Unable to create a form item. Attribute will be skipped.", type.name(), property.getName(), metadata.getTemplate());
                        break;
                    }
                    break;
                }
            case OBJECT:
                {
                    if (valueType != null && ModelType.STRING == valueType) {
                        PropertiesItem propertiesItem = new PropertiesItem(name, label);
                        List<Property> properties = ModelNodeHelper.getOrDefault(attributeDescription, DEFAULT, () -> attributeDescription.get(DEFAULT).asPropertyList(), emptyList());
                        if (!properties.isEmpty()) {
                            Map<String, String> defaultValues = new HashMap<>();
                            for (Property p : properties) {
                                defaultValues.put(p.getName(), p.getValue().asString());
                            }
                            propertiesItem.assignDefaultValue(defaultValues);
                        }
                        formItem = propertiesItem;
                    }
                    break;
                }
            case STRING:
                {
                    List<String> allowedValues = stringValues(attributeDescription, ALLOWED);
                    if (allowedValues.isEmpty()) {
                        FormItem<String> textBoxItem = new TextBoxItem(name, label, null);
                        boolean sensitive = failSafeGet(attributeDescription, ACCESS_CONSTRAINTS + "/" + SENSITIVE).isDefined();
                        if (PASSWORD.equals(name) || sensitive) {
                            textBoxItem.mask();
                        }
                        if (attributeDescription.hasDefined(DEFAULT)) {
                            textBoxItem.assignDefaultValue(attributeDescription.get(DEFAULT).asString());
                        }
                        formItem = textBoxItem;
                        checkCapabilityReference(attributeDescription, formItem);
                    } else {
                        SingleSelectBoxItem singleSelectBoxItem = new SingleSelectBoxItem(name, label, allowedValues, !required);
                        if (attributeDescription.hasDefined(DEFAULT)) {
                            singleSelectBoxItem.assignDefaultValue(attributeDescription.get(DEFAULT).asString());
                        }
                        formItem = singleSelectBoxItem;
                    }
                    break;
                }
            // unsupported types
            case BIG_DECIMAL:
            case BYTES:
            case EXPRESSION:
            case PROPERTY:
            case TYPE:
            case UNDEFINED:
                logger.warn("Unsupported model type {} for attribute {} in metadata {}. Unable to create a form item. Attribute will be skipped.", type.name(), property.getName(), metadata.getTemplate());
                break;
            default:
                break;
        }
        if (formItem != null) {
            formItem.setRequired(required);
            formItem.setDeprecated(deprecation);
            if (formItem.supportsExpressions()) {
                formItem.setExpressionAllowed(expressionAllowed);
                formItem.addResolveExpressionHandler(event -> {
                    // resend as application event
                    Core.INSTANCE.eventBus().fireEvent(event);
                });
            }
            if (readOnly) {
                formItem.setEnabled(false);
                // if the attribute is read-only and required, the form validation prevents to save the form
                // remove the required constraint to allow the save operation.
                formItem.setRequired(false);
            }
        }
    }
    return formItem;
}

Example 10 with TextBoxItem

use of org.jboss.hal.ballroom.form.TextBoxItem in project console by hal.

the class BrowseContentElement method uploadContent.

private void uploadContent() {
    LabelBuilder labelBuilder = new LabelBuilder();
    TextBoxItem targetPathItem = new TextBoxItem(TARGET_PATH);
    targetPathItem.setRequired(true);
    FileItem fileItem = new FileItem(FILE, labelBuilder.label(FILE));
    fileItem.addValueChangeHandler(event -> targetPathItem.setValue(appendFilename(targetPathItem.getValue(), event.getValue().name)));
    TextBoxItem urlItem = new TextBoxItem(URL, labelBuilder.label(URL));
    urlItem.addValueChangeHandler(event -> targetPathItem.setValue(appendFilename(targetPathItem.getValue(), filename(event.getValue()))));
    Form<ModelNode> form = new ModelNodeForm.Builder<>(Ids.CONTENT_NEW, Metadata.empty()).unboundFormItem(fileItem).unboundFormItem(urlItem).unboundFormItem(targetPathItem).addOnly().build();
    form.addFormValidation(f -> {
        if (fileItem.isEmpty() && urlItem.isEmpty()) {
            return ValidationResult.invalid(resources.messages().uploadContentInvalid());
        }
        return ValidationResult.OK;
    });
    form.setSaveCallback((f, model) -> {
        String path = targetPathItem.getValue();
        ResourceAddress address = new ResourceAddress().add(DEPLOYMENT, content.getName());
        ModelNode contentNode = new ModelNode();
        if (fileItem.isEmpty()) {
            contentNode.get(URL).set(urlItem.getValue());
        } else {
            contentNode.get(INPUT_STREAM_INDEX).set(0);
        }
        contentNode.get(TARGET_PATH).set(path);
        Operation operation = new Operation.Builder(address, ADD_CONTENT).param(CONTENT, new ModelNode().add(contentNode)).build();
        Single<ModelNode> single = fileItem.isEmpty() ? dispatcher.execute(operation) : dispatcher.upload(fileItem.getValue(), operation);
        single.toCompletable().andThen(browseContent()).andThen(awaitTreeReady()).subscribe(() -> {
            MessageEvent.fire(eventBus, Message.success(resources.messages().newContentSuccess(content.getName(), path)));
            tree.selectNode(NODE_ID.apply(path));
        });
    });
    Dialog dialog = new Dialog.Builder(resources.constants().uploadContent()).add(p().innerHtml(resources.messages().uploadContentDescription()).element()).add(form.element()).primary(resources.constants().upload(), form::save).size(Dialog.Size.MEDIUM).cancel().build();
    dialog.registerAttachable(form);
    targetPathItem.setValue(selectedPath());
    dialog.show();
    form.edit(new ModelNode());
}