protected <T> FormItem<T> formItem(List<FormItem> formItems, String name) {
   for (FormItem formItem : formItems) {
     if (name.equals(formItem.getName())) {
       return formItem;
     }
   }
   return null;
 }
Exemplo n.º 2
0
  public ModelNode getAttributeMetaData(String name) {

    ModelNode metaData = null;

    for (Map<String, FormItem> groupItems : formItems.values()) {
      for (FormItem item : groupItems.values()) {
        if (name.equals(item.getName())) {
          metaData = (ModelNode) item.getMetadata();
          break;
        }
      }
    }

    return metaData;
  }
Exemplo n.º 3
0
  @Override
  public Map<String, Object> getChangedValues() {

    final Map<String, Object> changedValues = new HashMap<String, Object>();
    final ModelNode src = editedEntity == null ? new ModelNode() : editedEntity;
    final ModelNode dest = getUpdatedEntity();

    ModelNodeInspector inspector = new ModelNodeInspector(this.getUpdatedEntity());
    inspector.accept(
        new ModelNodeVisitor() {
          @Override
          public boolean visitValueProperty(
              String propertyName, ModelNode value, PropertyContext ctx) {

            // protected mode (see edit() ) requires us to prevent mutation
            ModelNode modelNode = src.hasDefined(propertyName) ? src.get(propertyName) : UNDEFINED;

            if (!modelNode.equals(dest.get(propertyName))) {
              Object castedValue =
                  downCast(dest.get(propertyName), getAttributeMetaData(propertyName));
              changedValues.put(propertyName, castedValue);
            }

            return true;
          }
        });

    Map<String, Object> finalDiff = new HashMap<String, Object>();

    // map changes, but skip unmodified fields
    for (Map<String, FormItem> groupItems : formItems.values()) {
      for (FormItem item : groupItems.values()) {
        Object val = changedValues.get(item.getName());

        // expression have precedence over real values
        if (item.isExpressionValue()) {
          finalDiff.put(item.getName(), item.asExpressionValue());
        }

        // regular values
        else if (val != null && item.isModified()) {
          if (item.isUndefined()) finalDiff.put(item.getName(), FormItem.VALUE_SEMANTICS.UNDEFINED);
          else finalDiff.put(item.getName(), val);
        }
      }
    }

    return finalDiff;
  }
  private ToolStrip mainTableTools() {
    ToolStrip tools = new ToolStrip();
    ToolButton addButton =
        new ToolButton(
            Console.CONSTANTS.common_label_add(),
            event -> {
              ModelNodeFormBuilder.FormAssets addFormAssets =
                  new ModelNodeFormBuilder()
                      .setResourceDescription(resourceDescription)
                      .setCreateMode(true)
                      .unsorted()
                      .setCreateNameAttribute(false)
                      .setSecurityContext(securityContext)
                      .build();
              addFormAssets.getForm().setEnabled(true);
              addFormAssets
                  .getForm()
                  .addFormValidator(
                      (formItems, formValidation) -> {

                        // at least one field is necessary to fill
                        boolean allEmpty = true;
                        for (FormItem formItem : formItems) {
                          if (!formItem.isUndefined()) {
                            allEmpty = false;
                            break;
                          }
                        }
                        if (allEmpty) {
                          formValidation.addError("match-abstract-type");
                          FormItem mechanismNameFormItem =
                              formItem(formItems, "match-abstract-type");
                          mechanismNameFormItem.setErrMessage(
                              "At least one field must contain valid values.");
                          mechanismNameFormItem.setErroneous(true);
                        }
                      });

              DefaultWindow dialog = new DefaultWindow(Console.MESSAGES.newTitle("Match Rule"));
              AddResourceDialog.Callback callback =
                  new AddResourceDialog.Callback() {
                    @Override
                    public void onAdd(ModelNode payload) {
                      for (Property node : payload.asPropertyList()) {
                        // remove undefined attributes
                        if (!node.getValue().isDefined()) {
                          payload.remove(node.getName());
                        }
                      }
                      circuit.dispatch(
                          new AddListAttribute(
                              ElytronStore.AUTHENTICATION_CONTEXT_ADDRESS,
                              MATCH_RULES,
                              authContextName,
                              payload));
                      dialog.hide();
                    }

                    @Override
                    public void onCancel() {
                      dialog.hide();
                    }
                  };
              AddResourceDialog addDialog =
                  new AddResourceDialog(addFormAssets, resourceDescription, callback);
              dialog.setWidth(480);
              dialog.setHeight(510);
              dialog.setWidget(addDialog);
              dialog.setGlassEnabled(true);
              dialog.center();
            });
    ToolButton removeButton =
        new ToolButton(
            Console.CONSTANTS.common_label_delete(),
            event -> {
              final ModelNode selection = selectionModel.getSelectedObject();
              if (selection != null) {
                Feedback.confirm(
                    "Match Rule",
                    Console.MESSAGES.deleteConfirm("Match Rule " + selection.asString()),
                    isConfirmed -> {
                      if (isConfirmed) {
                        circuit.dispatch(
                            new RemoveListAttribute(
                                ElytronStore.AUTHENTICATION_CONTEXT_ADDRESS,
                                authContextName,
                                MATCH_RULES,
                                selection));
                      }
                    });
              }
            });
    tools.addToolButtonRight(addButton);
    tools.addToolButtonRight(removeButton);
    return tools;
  }
Exemplo n.º 5
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;
  }
Exemplo n.º 6
0
 @Override
 public void setErroneous(boolean b) {
   super.setErroneous(b);
   wrapper.setErroneous(b);
 }
Exemplo n.º 7
0
 @Override
 public void resetMetaData() {
   super.resetMetaData();
   textBox.setValue(null);
 }
Exemplo n.º 8
0
 @Override
 public void setFiltered(boolean filtered) {
   super.setFiltered(filtered);
   super.toggleAccessConstraint(textBox, filtered);
   textBox.setEnabled(!filtered);
 }