private void showDetailModal(final ModelNode selection) {

    matchRulesForm.editTransient(selection);
    Widget windowContent = new WindowContentBuilder(popupLayout, popupDialogOptions).build();

    matchRulesWindow = new DefaultWindow("Match Rule");
    matchRulesWindow.setWidth(480);
    matchRulesWindow.setHeight(430);
    matchRulesWindow.trapWidget(windowContent);
    matchRulesWindow.setGlassEnabled(true);
    matchRulesWindow.center();
  }
Ejemplo n.º 2
0
  private void _showAddDialog(
      final ModelNode address,
      boolean isSingleton,
      SecurityContext securityContext,
      ModelNode description) {
    List<Property> tuples = address.asPropertyList();
    String type = "";
    if (tuples.size() > 0) {
      type = tuples.get(tuples.size() - 1).getName();
    }

    ModelNodeFormBuilder builder =
        new ModelNodeFormBuilder()
            .setCreateMode(true)
            .setSingleton(isSingleton)
            .setResourceDescription(description)
            .setSecurityContext(securityContext);

    ModelNodeFormBuilder.FormAssets assets = builder.build();

    final ModelNodeForm form = assets.getForm();
    form.setEnabled(true);

    if (form.hasWritableAttributes()) {
      final DefaultWindow window = new DefaultWindow(Console.MESSAGES.createResource(type));
      window.addStyleName("browser-view");

      DialogueOptions options =
          new DialogueOptions(
              new ClickHandler() {
                @Override
                public void onClick(ClickEvent event) {
                  // save
                  FormValidation validation = form.validate();
                  if (!validation.hasErrors()) {
                    presenter.onAddChildResource(address, form.getUpdatedEntity());
                    window.hide();
                  }
                }
              },
              new ClickHandler() {
                @Override
                public void onClick(ClickEvent event) {
                  // cancel
                  window.hide();
                }
              });

      VerticalPanel layout = new VerticalPanel();
      layout.setStyleName("fill-layout-width");
      ModelNode opDescription = description.get("operations").get("add").get("description");
      ContentDescription text = new ContentDescription(opDescription.asString());
      layout.add(text);
      layout.add(assets.asWidget());

      WindowContentBuilder content = new WindowContentBuilder(layout, options);
      window.trapWidget(content.build());
      window.setGlassEnabled(true);
      window.setWidth(480);
      window.setHeight(360);
      window.center();
    } else {
      // no writable attributes
      Feedback.alert(
          Console.CONSTANTS.cannotCreateChildResource(),
          Console.MESSAGES.noConfigurableAttributes(address.toString()));
    }
  }
Ejemplo n.º 3
0
  public FormAssets build() {

    // pre-requisite
    if (createMode && !modelDescription.hasDefined("operations")) {
      throw new IllegalStateException("Operation descriptions not defined");
    }

    this.form = new ModelNodeForm(this.address, this.securityContext);
    this.form.setNumColumns(2);
    this.form.setEnabled(false);

    assert modelDescription.hasDefined("attributes")
        : "Invalid model description. Expected child 'attributes'";

    List<Property> attributeDescriptions = new ArrayList<Property>();
    if (createMode
        && modelDescription.get("operations").get("add").hasDefined("request-properties")) {
      attributeDescriptions =
          modelDescription.get("operations").get("add").get("request-properties").asPropertyList();
    } else if (!createMode) {
      attributeDescriptions = modelDescription.get("attributes").asPropertyList();
    }

    // sort fields
    if (!unsorted) {
      Collections.sort(
          attributeDescriptions,
          new Comparator<Property>() {
            @Override
            public int compare(Property property, Property property1) {
              return property.getName().compareTo(property1.getName());
            }
          });
    }

    // catch-all directive, if no explicit attributes given
    if (includes.isEmpty()) {
      for (Property attr : attributeDescriptions) {
        includes.add(attr.getName());
      }
    }
    // in any case remove attributes marked for exclusion
    includes.removeAll(excludes);

    LinkedList<FormItem> requiredItems = new LinkedList<FormItem>();
    LinkedList<FormItem> optionalItems = new LinkedList<FormItem>();

    SafeHtmlBuilder helpTexts = new SafeHtmlBuilder();
    helpTexts.appendHtmlConstant("<table class='help-attribute-descriptions'>");

    Map<String, ModelNode> defaultValues = new HashMap<String, ModelNode>();
    int numWritable = 0;

    boolean hasRequired = false;

    // for some decision below we need to know wether or not required attributes exist at all
    if (requiredOnly) {
      for (Property attr : attributeDescriptions) {
        ModelNode value = attr.getValue();
        boolean required = isRequired(value);
        boolean readOnly = value.get("access-type").asString().equals("read-only");
        if (required & !readOnly) {
          hasRequired = true;
          break;
        }
      }
    }

    Set<String[]> unsupportedTypes = new HashSet<>();
    for (String attribute : includes) {
      for (Property attr : attributeDescriptions) {

        boolean isRuntime = attr.getValue().get("storage").asString().equals("runtime");
        boolean isConfig =
            !attr.getValue().get("storage").asString().equals("runtime"); // TODO: verify statement

        if (runtimeAttributes == false && isRuntime) {
          continue;
        }

        if (configAttributes == false && isConfig) {
          continue;
        }

        if (!attr.getName().equals(attribute)) continue;

        // -------
        // Attribute meta data

        // name
        char[] attrName = attr.getName().toCharArray();
        attrName[0] = Character.toUpperCase(attrName[0]);

        // field label
        String label = new String(attrName).replace("-", " ");
        ModelNode attrDesc = attr.getValue();

        // skip deprecated attributes
        if (attrDesc.hasDefined("deprecated")) {
          // Log.error("Skip deprecated attribute '" + attr.getName() + "'");
          continue;
        }

        // type
        ModelType type = ModelType.valueOf(attrDesc.get("type").asString().toUpperCase());

        // default value
        if (attrDesc.hasDefined("default")) {
          ModelNode defaultValue = attrDesc.get("default");
          ModelNode value = new ModelNode();
          // value.set(type, ModelNodeForm.downCast(defaultValue));
          setValue(
              value,
              type,
              ModelNodeForm.downCast(defaultValue, attrDesc)); // workaround for numeric types

          defaultValues.put(attr.getName(), value);
        }

        // read-only
        final boolean readOnly =
            attrDesc.hasDefined("access-type")
                ? attrDesc.get("access-type").asString().equals("read-only")
                : false;

        // nillable
        boolean isRequired = isRequired(attrDesc);

        // createMode flag
        if ((createMode && readOnly)) continue;

        // requiredOnly flag
        if (requiredOnly && hasRequired && !isRequired) continue;

        // count writable attributes
        if (!readOnly && !isRuntime) numWritable++;

        // -------
        // help

        helpTexts.appendHtmlConstant("<tr class='help-field-row'>");
        helpTexts.appendHtmlConstant("<td class='help-field-name'>");
        helpTexts.appendEscaped(label).appendEscaped(": ");
        helpTexts.appendHtmlConstant("</td>");
        helpTexts.appendHtmlConstant("<td class='help-field-desc'>");
        try {
          String descWorkaround = attrDesc.get("description").asString();

          helpTexts.appendHtmlConstant(descWorkaround.equals("null") ? "n/a" : descWorkaround);
        } catch (Throwable e) {
          // ignore parse errors
          helpTexts.appendHtmlConstant("<i>Failed to parse description</i>");
        }
        helpTexts.appendHtmlConstant("</td>");
        helpTexts.appendHtmlConstant("</tr>");

        FormItem formItem = null;

        // explicitly created form items (monkey patching)
        if (itemFactories.containsKey(attr.getName())) {
          formItem = itemFactories.get(attr.getName()).create(attr);
        }

        // not created by explicit factory
        if (null == formItem) {
          switch (type) {
            case BOOLEAN:
              formItem = new CheckBoxItem(attr.getName(), label);
              formItem.setRequired(isRequired);
              formItem.setEnabled(!readOnly && !isRuntime);
              break;
            case DOUBLE:
              formItem = new DoubleFormItem(attr.getName(), label);
              formItem.setRequired(isRequired);
              formItem.setEnabled(!readOnly && !isRuntime);
              break;
            case LONG:
              boolean allowNegativeValues = false;
              if (attrDesc.hasDefined("default"))
                allowNegativeValues = attrDesc.get("default").asLong() < 0;

              formItem = new NumberBoxItem(attr.getName(), label, allowNegativeValues);
              formItem.setRequired(isRequired);
              formItem.setEnabled(!readOnly && !isRuntime);
              break;
            case BIG_DECIMAL:
              formItem = new NumberBoxItem(attr.getName(), label);
              formItem.setRequired(isRequired);
              formItem.setEnabled(!readOnly && !isRuntime);
              break;
            case INT:
              if (attrDesc.hasDefined("min") && attrDesc.hasDefined("max")) {
                formItem =
                    new NumberBoxItem(
                        attr.getName(),
                        label,
                        attrDesc.get("min").asLong(),
                        attrDesc.get("max").asLong());
              } else {
                formItem = new NumberBoxItem(attr.getName(), label);
              }

              formItem.setRequired(isRequired);
              formItem.setEnabled(!readOnly && !isRuntime);

              break;
            case LIST:
              formItem = new ListItem(attr.getName(), label);
              formItem.setRequired(isRequired);
              formItem.setEnabled(!readOnly && !isRuntime);
              break;
            case STRING:
              if (attrDesc.get("allowed").isDefined()) {
                List<ModelNode> allowed = attrDesc.get("allowed").asList();
                Set<String> allowedValues = new HashSet<String>(allowed.size());
                for (ModelNode value : allowed) allowedValues.add(value.asString());

                final boolean isNillable =
                    attrDesc.hasDefined(NILLABLE) && attrDesc.get(NILLABLE).asBoolean();
                ComboBoxItem combo = new ComboBoxItem(attr.getName(), label, isNillable);
                combo.setValueMap(allowedValues);
                combo.setEnabled(!readOnly && !isRuntime);
                combo.setRequired(isRequired);

                formItem = combo;
              } else {
                formItem = createSuggestBoxForCapabilityReference(attr, label, isRequired);
                if (formItem == null) {
                  // there is no capability-reference
                  TextBoxItem textBoxItem = new TextBoxItem(attr.getName(), label);
                  textBoxItem.setAllowWhiteSpace(true);

                  textBoxItem.setRequired(isRequired);
                  textBoxItem.setEnabled(!readOnly && !isRuntime);

                  formItem = textBoxItem;
                }
              }

              // TODO: Support for TextAreaItem

              break;
            case OBJECT:
              if (attrDesc.has("value-type")
                  && attrDesc.get("value-type").asString().equals("STRING")) {
                PropertyListItem propList = new PropertyListItem(attr.getName(), label);
                propList.setRequired(isRequired);
                propList.setEnabled(!readOnly && !isRuntime);

                formItem = propList;
                break;
              }
            default:
              {
                unsupportedTypes.add(new String[] {attr.getName(), type.toString()});
                Log.error("Unsupported ModelType " + type + ", attribute '" + attr.getName() + "'");
              }
          }
        }

        if (formItem != null) {
          if (createMode) {
            if (isRequired && includeOptionals) requiredItems.add(formItem);
            else optionalItems.add(formItem);
          } else {
            requiredItems.add(formItem);
          }

          // attribute meta data attached to form item
          formItem.setMetadata(attrDesc);
        }
      }
    }

    // some resources already contain a name attribute
    FormItem nameItem = null;
    if (createMode) {
      for (FormItem item : requiredItems) {
        if ("name".equals(item.getName())) {
          nameItem = item;
          break;
        }
      }
      for (FormItem item : optionalItems) {
        if ("name".equals(item.getName())) {
          nameItem = item;
          break;
        }
      }
    }

    // remove so it can be prepended
    if (nameItem != null) {
      requiredItems.remove(nameItem);
      optionalItems.remove(nameItem);
    }

    // distinguish required and optional fields (createMode)
    if (requiredItems.isEmpty()) {
      // no required fields explicitly given, treat all fields as required
      if (createMode) {
        optionalItems.addFirst(new TextBoxItem("name", "Name", true));
        numWritable++;
      }
      form.setFields(optionalItems.toArray(new FormItem[] {}));
    } else {
      if (createMode) {
        requiredItems.addFirst(new TextBoxItem("name", "Name", true));
        numWritable++;
      }

      form.setFields(requiredItems.toArray(new FormItem[] {}));

      if (optionalItems.size() > 0)
        form.setFieldsInGroup(
            "Optional Fields",
            new DisclosureGroupRenderer(),
            optionalItems.toArray(new FormItem[] {}));
    }

    // form meta data
    form.setDefaults(defaultValues);
    form.setHasWritableAttributes(numWritable > 0);

    FormAssets formAssets = new FormAssets(form, helpTexts.toSafeHtml());
    formAssets.setUnsupportedTypes(unsupportedTypes);
    return formAssets;
  }