public void showErrors(List<EditorError> errors) {
   SafeHtmlBuilder b = new SafeHtmlBuilder();
   for (EditorError error : errors) {
     b.appendEscaped(error.getPath()).appendEscaped(": ");
     b.appendEscaped(error.getMessage()).appendHtmlConstant("<br>");
   }
   this.errors.setInnerHTML(b.toSafeHtml().asString());
 }
Exemplo n.º 2
0
  private static void matchSubElements(
      ModelNode descriptionModel, List<String> fieldNames, SafeHtmlBuilder html) {

    if (descriptionModel.hasDefined(RESULT))
      descriptionModel = descriptionModel.get(RESULT).asObject();

    try {

      // match attributes
      if (descriptionModel.hasDefined(ATTRIBUTES)) {

        List<Property> elements = descriptionModel.get(ATTRIBUTES).asPropertyList();

        for (Property element : elements) {
          String childName = element.getName();
          ModelNode value = element.getValue();

          if (fieldNames.contains(childName)) {
            // make sure it's not processed twice
            fieldNames.remove(childName);

            html.appendHtmlConstant("<tr class='help-field-row'>");
            html.appendHtmlConstant("<td class='help-field-name'>");
            html.appendEscaped(childName).appendEscaped(": ");
            html.appendHtmlConstant("</td>");
            html.appendHtmlConstant("<td class='help-field-desc'>");
            html.appendEscaped(value.get("description").asString());
            html.appendHtmlConstant("</td>");
            html.appendHtmlConstant("</tr>");
          }
        }
      }

      if (fieldNames.isEmpty()) return;

      // visit child elements
      if (descriptionModel.hasDefined("children")) {
        List<Property> children = descriptionModel.get("children").asPropertyList();

        for (Property child : children) {
          ModelNode childDesc = child.getValue();
          for (Property modDescProp : childDesc.get(MODEL_DESCRIPTION).asPropertyList()) {

            matchSubElements(
                childDesc.get(MODEL_DESCRIPTION, modDescProp.getName()), fieldNames, html);

            // exit early
            if (fieldNames.isEmpty()) return;
          }
        }
      }

    } catch (IllegalArgumentException e) {
      Log.error("Failed to read help descriptionModel", e);
    }
  }
Exemplo n.º 3
0
 private static void addHelpTextRow(SafeHtmlBuilder builder, String name, String desc) {
   builder.appendHtmlConstant("<tr class='help-field-row'>");
   builder.appendHtmlConstant("<td class='help-field-name'>");
   builder.appendEscaped(name);
   builder.appendHtmlConstant("</td>");
   builder.appendHtmlConstant("<td class='help-field-desc'>");
   builder.appendEscaped(desc);
   builder.appendHtmlConstant("</td>");
   builder.appendHtmlConstant("</tr>");
 }
  public void render(Context context, Semesterverband value, SafeHtmlBuilder sb) {

    if (value == null) {
      return;
    }

    sb.appendHtmlConstant("<div>");
    sb.appendEscaped(value.getStudiengang().getKuerzel() + " ");
    sb.appendEscaped(value.getJahrgang());
    sb.appendHtmlConstant("</div>");
  }
Exemplo n.º 5
0
 @Override
 public void render(Context context, T value, SafeHtmlBuilder sb) {
   lastContext = context;
   if (value != null) {
     sb.appendEscaped(String.valueOf(value));
   }
 }
Exemplo n.º 6
0
 public static String getError(String message) {
   SafeHtmlBuilder builder = new SafeHtmlBuilder();
   builder.append(
       SafeHtmlUtils.fromTrustedString(
           "<html><title>Getting credentials failed</title><body><div align=\"center\"><p><h1>Getting credentails failed</h1></p><p><img src=\"themes/active/logo.png\" /></p><p><h3 style=\"font-color: red;\">"));
   builder.appendEscaped(message);
   builder.append(SafeHtmlUtils.fromTrustedString("</h3></p></div></body></html>"));
   return builder.toSafeHtml().asString();
 }
Exemplo n.º 7
0
    @Override
    public void render(ContactInfo value, Object key, SafeHtmlBuilder sb) {
      // Value can be null, so do a null check..
      if (value == null) {
        return;
      }

      sb.appendHtmlConstant("<table>");

      // Add the contact image.
      sb.appendHtmlConstant("<tr><td rowspan='3'>");
      sb.appendHtmlConstant(imageHtml);
      sb.appendHtmlConstant("</td>");

      // Add the name and address.
      sb.appendHtmlConstant("<td style='font-size:95%;'>");
      sb.appendEscaped(value.getFullName());
      sb.appendHtmlConstant("</td></tr><tr><td>");
      sb.appendEscaped(value.getAddress());
      sb.appendHtmlConstant("</td></tr></table>");
    }
Exemplo n.º 8
0
 @Override
 public void updateSearchLabel(String query, String path) {
   SafeHtmlBuilder builder = new SafeHtmlBuilder();
   builder
       .appendEscaped("Results for ")
       .appendHtmlConstant("<strong>")
       .appendEscaped(query)
       .appendHtmlConstant("</strong>")
       .appendEscaped(" in ")
       .appendEscaped(path);
   searchLabel_.getElement().setInnerHTML(builder.toSafeHtml().asString());
 }
  private void setNick(UserDataProxy userData) {
    if (userData == null) {
      return;
    }

    String nick = userData.getGoogleNickname();

    // This is a must, always clean before draw
    SafeHtmlBuilder builder = new SafeHtmlBuilder();
    builder.appendEscaped(nick);

    htmlNick.setHTML(builder.toSafeHtml());
  }
Exemplo n.º 10
0
 /** @see com.google.gwt.editor.client.HasEditorErrors#showErrors(java.util.List) */
 @Override
 public void showErrors(List<EditorError> errors) {
   Widget decoratedWidget = controlGroup != null ? controlGroup : this;
   if (errors != null && !errors.isEmpty()) {
     StyleHelper.addStyle(decoratedWidget, ControlGroupType.ERROR);
     SafeHtmlBuilder sb = new SafeHtmlBuilder();
     for (EditorError error : errors) {
       if (error.getEditor() == this) {
         sb.appendEscaped(error.getMessage());
         sb.appendHtmlConstant("<br />");
       }
     }
     setErrorLabelText(sb.toSafeHtml().asString());
   } else {
     StyleHelper.removeStyle(decoratedWidget, ControlGroupType.ERROR);
     setErrorLabelText("");
   }
 }
 @Override
 public void render(SafeHtmlBuilder safeHtmlBuilder, Header model) {
   safeHtmlBuilder.appendEscaped(model.getName());
 }
  @Override
  public void start(AcceptsOneWidget panel, final EventBus eventBus) {
    view = clientFactory.getRestAreaView();
    analytics = clientFactory.getAnalytics();
    accessibility = clientFactory.getAccessibility();
    this.eventBus = eventBus;
    view.setPresenter(this);

    Place place = clientFactory.getPlaceController().getWhere();

    if (place instanceof RestAreaPlace) {
      RestAreaPlace restAreaPlace = (RestAreaPlace) place;

      int restAreaId = Integer.valueOf(restAreaPlace.getId());

      String jsonString = AppBundle.INSTANCE.restAreaData().getText();
      RestAreaFeed restAreas = JsonUtils.safeEval(jsonString);

      view.setTitle("Safety Rest Area");

      SafeHtmlBuilder detailsHTMLBuilder = new SafeHtmlBuilder();

      detailsHTMLBuilder.appendEscaped(
          restAreas.getRestAreas().get(restAreaId).getRoute()
              + " - "
              + restAreas.getRestAreas().get(restAreaId).getLocation());

      detailsHTMLBuilder.appendHtmlConstant("<br>");

      detailsHTMLBuilder.appendEscaped(
          "Milepost: "
              + restAreas.getRestAreas().get(restAreaId).getMilepost()
              + " - "
              + restAreas.getRestAreas().get(restAreaId).getDirection());

      view.setDetails(detailsHTMLBuilder.toSafeHtml());

      if (restAreas.getRestAreas().get(restAreaId).getNotes() == null) {
        view.hideNotesHeading();
        view.setNotes("");
      } else {
        view.showNotesHeading();
        view.setNotes(restAreas.getRestAreas().get(restAreaId).getNotes());
      }

      SafeHtmlBuilder amenitiesHTMLBuilder = new SafeHtmlBuilder();

      amenitiesHTMLBuilder.appendHtmlConstant("<ul>");
      for (int i = 0; i < restAreas.getRestAreas().get(restAreaId).getAmenities().length; i++) {
        amenitiesHTMLBuilder.appendHtmlConstant("<li>");
        amenitiesHTMLBuilder.appendEscaped(
            restAreas.getRestAreas().get(restAreaId).getAmenities()[i]);
        amenitiesHTMLBuilder.appendHtmlConstant("</li>");
      }

      if (restAreas.getRestAreas().get(restAreaId).getAmenities().length == 0) {
        view.hideAmenitiesHeading();
      } else {
        view.showAmenitiesHeading();
      }

      amenitiesHTMLBuilder.appendHtmlConstant("</ul>");

      view.setAmenities(amenitiesHTMLBuilder.toSafeHtml());

      view.setLatLon(
          Double.valueOf(restAreas.getRestAreas().get(restAreaId).getLatitude()),
          Double.valueOf(restAreas.getRestAreas().get(restAreaId).getLongitude()));

      view.refresh();
    }

    panel.setWidget(view);
    accessibility.postScreenChangeNotification();
  }
Exemplo n.º 13
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;
  }
 public void render(Cell.Context context, C value, SafeHtmlBuilder sb) {
   sb.appendEscaped(propertyEditor.render(value));
 }