コード例 #1
0
ファイル: OutputTextTag.java プロジェクト: baraujo75/mojarra
  protected void setProperties(UIComponent component) {
    super.setProperties(component);
    javax.faces.component.UIOutput output = null;
    try {
      output = (javax.faces.component.UIOutput) component;
    } catch (ClassCastException cce) {
      throw new IllegalStateException(
          "Component "
              + component.toString()
              + " not expected type.  Expected: javax.faces.component.UIOutput.  Perhaps you're missing a tag?");
    }

    if (converter != null) {
      if (!converter.isLiteralText()) {
        output.setValueExpression("converter", converter);
      } else {
        Converter conv =
            FacesContext.getCurrentInstance()
                .getApplication()
                .createConverter(converter.getExpressionString());
        output.setConverter(conv);
      }
    }

    if (value != null) {
      if (!value.isLiteralText()) {
        output.setValueExpression("value", value);
      } else {
        output.setValue(value.getExpressionString());
      }
    }
    if (escape != null) {
      if (!escape.isLiteralText()) {
        output.setValueExpression("escape", escape);
      } else {
        output
            .getAttributes()
            .put("escape", java.lang.Boolean.valueOf(escape.getExpressionString()));
      }
    }
    if (style != null) {
      if (!style.isLiteralText()) {
        output.setValueExpression("style", style);
      } else {
        output.getAttributes().put("style", style.getExpressionString());
      }
    }
    if (styleClass != null) {
      if (!styleClass.isLiteralText()) {
        output.setValueExpression("styleClass", styleClass);
      } else {
        output.getAttributes().put("styleClass", styleClass.getExpressionString());
      }
    }
  }
コード例 #2
0
 public Object getAsObject(FacesContext context, UIComponent component, String value) {
   Converter delegate = getDelegate(context);
   if (delegate != null) {
     return delegate.getAsObject(context, component, value);
   } else {
     throw new ConverterException(
         MessageUtils.getExceptionMessage(
             MessageUtils.CANNOT_CONVERT_ID,
             converterId != null ? converterId.getExpressionString() : "",
             binding != null ? binding.getExpressionString() : ""));
   }
 }
コード例 #3
0
    /**
     * Perform the correctness checks implemented by this {@link javax.faces.validator.Validator}
     * against the specified {@link javax.faces.component.UIComponent}. If any violations are found,
     * a {@link javax.faces.validator.ValidatorException} will be thrown containing the {@link
     * javax.faces.application.FacesMessage} describing the failure.
     *
     * @param context FacesContext for the request we are processing
     * @param component UIComponent we are checking for correctness
     * @param value the value to validate
     * @throws javax.faces.validator.ValidatorException if validation fails
     * @throws NullPointerException if <code>context</code> or <code>component</code> is <code>null
     *     </code>
     */
    public void validate(FacesContext context, UIComponent component, Object value)
        throws ValidatorException {

      Validator instance = createValidator(validatorId, binding, context);

      if (instance != null) {
        instance.validate(context, component, value);
      } else {
        throw new ValidatorException(
            MessageUtils.getExceptionMessage(
                MessageUtils.CANNOT_VALIDATE_ID,
                validatorId != null ? validatorId.getExpressionString() : "",
                binding != null ? binding.getExpressionString() : ""));
      }
    }
コード例 #4
0
ファイル: ValueBinding.java プロジェクト: rafabene/XSeam2
 /**
  * * @see com.sun.facelets.FaceletHandler#apply(com.sun.facelets.FaceletContext,
  * javax.faces.component.UIComponent)
  */
 public void apply(FaceletContext ctx, UIComponent parent)
     throws IOException, FacesException, FaceletException, ELException {
   VariableMapper origVarMap = ctx.getVariableMapper();
   try {
     VariableMapperWrapper variableMap = new VariableMapperWrapper(origVarMap);
     ctx.setVariableMapper(variableMap);
     if (methodBindings != null) {
       String value = (String) methodBindings.getValue(ctx);
       Matcher match = METHOD_PATTERN.matcher(value);
       while (match.find()) {
         String var = match.group(1);
         ValueExpression currentExpression = origVarMap.resolveVariable(var);
         if (currentExpression != null) {
           try {
             FunctionMethodData methodData =
                 new FunctionMethodData(var, match.group(2).split("\\s+"));
             MethodExpression mexpr =
                 buildMethodExpression(ctx, currentExpression.getExpressionString(), methodData);
             variableMap.setVariable(var, new MethodValueExpression(currentExpression, mexpr));
           } catch (Exception ex) {
             throw new FacesException(ex);
           }
         }
       }
     }
     componentHandler.apply(ctx, parent);
   } finally {
     ctx.setVariableMapper(origVarMap);
   }
 }
コード例 #5
0
ファイル: ELUtils.java プロジェクト: jigg4/richfaces
 public static Object evaluateValueExpression(ValueExpression expression, ELContext elContext) {
   if (expression.isLiteralText()) {
     return expression.getExpressionString();
   } else {
     return expression.getValue(elContext);
   }
 }
コード例 #6
0
ファイル: BeanValidator.java プロジェクト: juangon/mojarra
  private boolean isResolvable(ValueReference ref, ValueExpression valueExpression) {
    Boolean result = null;
    String failureMessage = null;

    if (null == valueExpression) {
      failureMessage =
          "Unable to validate expression using Bean " + "Validation.  Expression must not be null.";
      result = false;
    } else if (null == ref) {
      failureMessage =
          "Unable to validate expression "
              + valueExpression.getExpressionString()
              + " using Bean Validation.  Unable to get value of expression.";
      result = false;
    } else {
      Class baseClass = ref.getBaseClass();

      // case 1, base classes of Map, List, or Array are not resolvable
      if (null != baseClass) {
        if (Map.class.isAssignableFrom(baseClass)
            || Collection.class.isAssignableFrom(baseClass)
            || Array.class.isAssignableFrom(baseClass)) {
          failureMessage =
              "Unable to validate expression "
                  + valueExpression.getExpressionString()
                  + " using Bean Validation.  Expression evaluates to a Map, List or array.";
          result = false;
        }
      }
    }

    result = ((null != result) ? result : true);
    if (!result) {
      LOGGER.fine(failureMessage);
    }

    return result;
  }
コード例 #7
0
  /**
   * Attempt to obtain the resource from the server by parsing the valueExpression of the image
   * attribute. Returns null if the valueExpression is not of the form
   * #{resource['path/to/resource']} or #{resource['library:name']}. Otherwise returns the value
   * obtained by ResourceHandler.createResource().
   */
  private Resource getImageResource(FacesContext facesContext, ImageCropper imageCropper) {

    Resource resource = null;
    ValueExpression imageValueExpression =
        imageCropper.getValueExpression(ImageCropper.PropertyKeys.image.toString());

    if (imageValueExpression != null) {
      String imageValueExpressionString = imageValueExpression.getExpressionString();

      if (imageValueExpressionString.matches("^[#][{]resource\\['[^']+'\\][}]$")) {

        imageValueExpressionString =
            imageValueExpressionString.replaceFirst("^[#][{]resource\\['", "");
        imageValueExpressionString = imageValueExpressionString.replaceFirst("'\\][}]$", "");
        String resourceLibrary = null;
        String resourceName;
        String[] resourceInfo = imageValueExpressionString.split(":");

        if (resourceInfo.length == 2) {
          resourceLibrary = resourceInfo[0];
          resourceName = resourceInfo[1];
        } else {
          resourceName = resourceInfo[0];
        }

        if (resourceName != null) {
          Application application = facesContext.getApplication();
          ResourceHandler resourceHandler = application.getResourceHandler();

          if (resourceLibrary != null) {
            resource = resourceHandler.createResource(resourceName, resourceLibrary);
          } else {
            resource = resourceHandler.createResource(resourceName);
          }
        }
      }
    }

    return resource;
  }
コード例 #8
0
 static Object saveWithType(ValueExpression expr, FacesContext context) {
   if (expr != null) {
     return new Object[] {expr.getExpressionString(), expr.getExpectedType()};
   } else return null;
 }
コード例 #9
0
  protected void setProperties(UIComponent component) {
    super.setProperties(component);
    javax.faces.component.UISelectOne selectone = null;
    try {
      selectone = (javax.faces.component.UISelectOne) component;
    } catch (ClassCastException cce) {
      throw new IllegalStateException(
          "Component "
              + component.toString()
              + " not expected type.  Expected: javax.faces.component.UISelectOne.  Perhaps you're missing a tag?");
    }

    if (converter != null) {
      if (!converter.isLiteralText()) {
        selectone.setValueExpression("converter", converter);
      } else {
        Converter conv =
            FacesContext.getCurrentInstance()
                .getApplication()
                .createConverter(converter.getExpressionString());
        selectone.setConverter(conv);
      }
    }

    if (converterMessage != null) {
      selectone.setValueExpression("converterMessage", converterMessage);
    }

    if (immediate != null) {
      selectone.setValueExpression("immediate", immediate);
    }

    if (required != null) {
      selectone.setValueExpression("required", required);
    }

    if (requiredMessage != null) {
      selectone.setValueExpression("requiredMessage", requiredMessage);
    }

    if (validator != null) {
      selectone.addValidator(new MethodExpressionValidator(validator));
    }
    if (validatorMessage != null) {
      selectone.setValueExpression("validatorMessage", validatorMessage);
    }

    if (value != null) {
      selectone.setValueExpression("value", value);
    }

    if (valueChangeListener != null) {
      selectone.addValueChangeListener(
          new MethodExpressionValueChangeListener(valueChangeListener));
    }
    if (accesskey != null) {
      selectone.setValueExpression("accesskey", accesskey);
    }
    if (dir != null) {
      selectone.setValueExpression("dir", dir);
    }
    if (disabled != null) {
      selectone.setValueExpression("disabled", disabled);
    }
    if (disabledClass != null) {
      selectone.setValueExpression("disabledClass", disabledClass);
    }
    if (enabledClass != null) {
      selectone.setValueExpression("enabledClass", enabledClass);
    }
    if (label != null) {
      selectone.setValueExpression("label", label);
    }
    if (lang != null) {
      selectone.setValueExpression("lang", lang);
    }
    if (onblur != null) {
      selectone.setValueExpression("onblur", onblur);
    }
    if (onchange != null) {
      selectone.setValueExpression("onchange", onchange);
    }
    if (onclick != null) {
      selectone.setValueExpression("onclick", onclick);
    }
    if (ondblclick != null) {
      selectone.setValueExpression("ondblclick", ondblclick);
    }
    if (onfocus != null) {
      selectone.setValueExpression("onfocus", onfocus);
    }
    if (onkeydown != null) {
      selectone.setValueExpression("onkeydown", onkeydown);
    }
    if (onkeypress != null) {
      selectone.setValueExpression("onkeypress", onkeypress);
    }
    if (onkeyup != null) {
      selectone.setValueExpression("onkeyup", onkeyup);
    }
    if (onmousedown != null) {
      selectone.setValueExpression("onmousedown", onmousedown);
    }
    if (onmousemove != null) {
      selectone.setValueExpression("onmousemove", onmousemove);
    }
    if (onmouseout != null) {
      selectone.setValueExpression("onmouseout", onmouseout);
    }
    if (onmouseover != null) {
      selectone.setValueExpression("onmouseover", onmouseover);
    }
    if (onmouseup != null) {
      selectone.setValueExpression("onmouseup", onmouseup);
    }
    if (onselect != null) {
      selectone.setValueExpression("onselect", onselect);
    }
    if (readonly != null) {
      selectone.setValueExpression("readonly", readonly);
    }
    if (style != null) {
      selectone.setValueExpression("style", style);
    }
    if (styleClass != null) {
      selectone.setValueExpression("styleClass", styleClass);
    }
    if (tabindex != null) {
      selectone.setValueExpression("tabindex", tabindex);
    }
    if (title != null) {
      selectone.setValueExpression("title", title);
    }
  }
コード例 #10
0
  /**
   * @see ViewHandler#retargetMethodExpressions(javax.faces.context.FacesContext,
   *     javax.faces.component.UIComponent)
   */
  @Override
  public void retargetMethodExpressions(FacesContext context, UIComponent topLevelComponent) {
    BeanInfo componentBeanInfo =
        (BeanInfo) topLevelComponent.getAttributes().get(UIComponent.BEANINFO_KEY);
    // PENDING(edburns): log error message if componentBeanInfo is null;
    if (null == componentBeanInfo) {
      return;
    }
    PropertyDescriptor attributes[] = componentBeanInfo.getPropertyDescriptors();
    String targets = null, attrName = null, strValue = null, methodSignature = null;
    UIComponent target = null;
    ExpressionFactory expressionFactory = null;
    ValueExpression valueExpression = null;
    MethodExpression toApply = null;
    Class expectedReturnType = null;
    Class expectedParameters[] = null;

    for (PropertyDescriptor cur : attributes) {
      // If the current attribute represents a ValueExpression
      if (null != (valueExpression = (ValueExpression) cur.getValue("type"))) {
        // take no action on this attribute.
        continue;
      }
      // If the current attribute representes a MethodExpression
      if (null != (valueExpression = (ValueExpression) cur.getValue("method-signature"))) {
        methodSignature = (String) valueExpression.getValue(context.getELContext());
        if (null != methodSignature) {

          // This is the name of the attribute on the top level component,
          // and on the inner component.
          if (null != (valueExpression = (ValueExpression) cur.getValue("targets"))) {
            targets = (String) valueExpression.getValue(context.getELContext());
          }

          if (null == targets) {
            targets = cur.getName();
          }

          if (null == targets || 0 == targets.length()) {
            // PENDING error message in page?
            logger.severe("Unable to retarget MethodExpression: " + methodSignature);
            continue;
          }

          String[] targetIds = targets.split(" ");

          for (String curTarget : targetIds) {

            attrName = cur.getName();

            // Find the attribute on the top level component
            valueExpression = (ValueExpression) topLevelComponent.getAttributes().get(attrName);
            if (null == valueExpression) {
              // PENDING error message in page?
              logger.severe(
                  "Unable to find attribute with name \""
                      + attrName
                      + "\" in top level component in consuming page.  "
                      + "Page author error.");
              continue;
            }

            // lazily initialize this local variable
            if (null == expressionFactory) {
              expressionFactory = context.getApplication().getExpressionFactory();
            }

            // If the attribute is one of the pre-defined
            // MethodExpression attributes
            boolean isAction = false,
                isActionListener = false,
                isValidator = false,
                isValueChangeListener = false;
            if ((isAction = attrName.equals("action"))
                || (isActionListener = attrName.equals("actionListener"))
                || (isValidator = attrName.equals("validator"))
                || (isValueChangeListener = attrName.equals("valueChangeListener"))) {
              // This is the inner component to which the attribute should
              // be applied
              target = topLevelComponent.findComponent(curTarget);
              if (null == targets) {
                // PENDING error message in page?
                logger.severe(
                    "Unable to retarget MethodExpression.  "
                        + "Unable to find inner component with id "
                        + targets
                        + ".");
                continue;
              }

              if (isAction) {
                expectedReturnType = Object.class;
                expectedParameters = new Class[] {};
                toApply =
                    expressionFactory.createMethodExpression(
                        context.getELContext(),
                        valueExpression.getExpressionString(),
                        expectedReturnType,
                        expectedParameters);
                ((ActionSource2) target).setActionExpression(toApply);
              } else if (isActionListener) {
                expectedReturnType = Void.TYPE;
                expectedParameters = new Class[] {ActionEvent.class};
                toApply =
                    expressionFactory.createMethodExpression(
                        context.getELContext(),
                        valueExpression.getExpressionString(),
                        expectedReturnType,
                        expectedParameters);
                ((ActionSource2) target)
                    .addActionListener(new MethodExpressionActionListener(toApply));
              } else if (isValidator) {
                expectedReturnType = Void.TYPE;
                expectedParameters =
                    new Class[] {FacesContext.class, UIComponent.class, Object.class};
                toApply =
                    expressionFactory.createMethodExpression(
                        context.getELContext(),
                        valueExpression.getExpressionString(),
                        expectedReturnType,
                        expectedParameters);
                ((EditableValueHolder) target).addValidator(new MethodExpressionValidator(toApply));
              } else if (isValueChangeListener) {
                expectedReturnType = Void.TYPE;
                expectedParameters = new Class[] {ValueChangeEvent.class};
                toApply =
                    expressionFactory.createMethodExpression(
                        context.getELContext(),
                        valueExpression.getExpressionString(),
                        expectedReturnType,
                        expectedParameters);
                ((EditableValueHolder) target)
                    .addValueChangeListener(new MethodExpressionValueChangeListener(toApply));
              }
            } else {
              // There is no explicit methodExpression property on
              // an inner component to which this MethodExpression
              // should be retargeted.  In this case, replace the
              // ValueExpression with a method expresson.

              // Pull apart the methodSignature to derive the
              // expectedReturnType and expectedParameters

              // PENDING(rlubke,jimdriscoll) bulletproof this

              assert (null != methodSignature);
              methodSignature = methodSignature.trim();

              // Get expectedReturnType
              int j, i = methodSignature.indexOf(" ");
              if (-1 != i) {
                strValue = methodSignature.substring(0, i);
                try {
                  expectedReturnType = Util.getTypeFromString(strValue);
                } catch (ClassNotFoundException cnfe) {
                  logger.log(
                      Level.SEVERE,
                      "Unable to determine expected return type for " + methodSignature,
                      cnfe);
                  continue;
                }
              } else {
                logger.severe("Unable to determine expected return type for " + methodSignature);
                continue;
              }

              // derive the arguments
              i = methodSignature.indexOf("(");
              if (-1 != i) {
                j = methodSignature.indexOf(")", i + 1);
                if (-1 != j) {
                  strValue = methodSignature.substring(i + 1, j);
                  if (0 < strValue.length()) {
                    String[] params = strValue.split(",");
                    expectedParameters = new Class[params.length];
                    boolean exceptionThrown = false;
                    for (i = 0; i < params.length; i++) {
                      try {
                        expectedParameters[i] = Util.getTypeFromString(params[i]);
                      } catch (ClassNotFoundException cnfe) {
                        logger.log(
                            Level.SEVERE,
                            "Unable to determine expected return type for " + methodSignature,
                            cnfe);
                        exceptionThrown = true;
                        break;
                      }
                    }
                    if (exceptionThrown) {
                      continue;
                    }

                  } else {
                    expectedParameters = new Class[] {};
                  }
                }
              }

              assert (null != expectedReturnType);
              assert (null != expectedParameters);

              toApply =
                  expressionFactory.createMethodExpression(
                      context.getELContext(),
                      valueExpression.getExpressionString(),
                      expectedReturnType,
                      expectedParameters);
              topLevelComponent.getAttributes().put(attrName, toApply);
            }
          }
        }
      }
    }
  }
コード例 #11
0
  protected void setProperties(UIComponent component) {
    super.setProperties(component);
    javax.faces.component.UICommand command = null;
    try {
      command = (javax.faces.component.UICommand) component;
    } catch (ClassCastException cce) {
      throw new IllegalStateException(
          "Component "
              + component.toString()
              + " not expected type.  Expected: javax.faces.component.UICommand.  Perhaps you're missing a tag?");
    }

    if (action != null) {
      command.setActionExpression(action);
    }
    if (actionListener != null) {
      command.addActionListener(new MethodExpressionActionListener(actionListener));
    }
    if (immediate != null) {
      if (!immediate.isLiteralText()) {
        command.setValueExpression("immediate", immediate);
      } else {
        command.setImmediate(
            java.lang.Boolean.valueOf(immediate.getExpressionString()).booleanValue());
      }
    }
    if (label != null) {
      if (!label.isLiteralText()) {
        command.setValueExpression("label", label);
      } else {
        command.getAttributes().put("label", label.getExpressionString());
      }
    }
    if (oncommand != null) {
      if (!oncommand.isLiteralText()) {
        command.setValueExpression("oncommand", oncommand);
      } else {
        command.getAttributes().put("oncommand", oncommand.getExpressionString());
      }
    }
    if (onclick != null) {
      if (!onclick.isLiteralText()) {
        command.setValueExpression("onclick", onclick);
      } else {
        command.getAttributes().put("onclick", onclick.getExpressionString());
      }
    }
    if (onfocusin != null) {
      if (!onfocusin.isLiteralText()) {
        command.setValueExpression("onfocusin", onfocusin);
      } else {
        command.getAttributes().put("onfocusin", onfocusin.getExpressionString());
      }
    }
    if (onfocusout != null) {
      if (!onfocusout.isLiteralText()) {
        command.setValueExpression("onfocusout", onfocusout);
      } else {
        command.getAttributes().put("onfocusout", onfocusout.getExpressionString());
      }
    }
    if (onmousedown != null) {
      if (!onmousedown.isLiteralText()) {
        command.setValueExpression("onmousedown", onmousedown);
      } else {
        command.getAttributes().put("onmousedown", onmousedown.getExpressionString());
      }
    }
    if (onmousemove != null) {
      if (!onmousemove.isLiteralText()) {
        command.setValueExpression("onmousemove", onmousemove);
      } else {
        command.getAttributes().put("onmousemove", onmousemove.getExpressionString());
      }
    }
    if (onmouseout != null) {
      if (!onmouseout.isLiteralText()) {
        command.setValueExpression("onmouseout", onmouseout);
      } else {
        command.getAttributes().put("onmouseout", onmouseout.getExpressionString());
      }
    }
    if (onmouseover != null) {
      if (!onmouseover.isLiteralText()) {
        command.setValueExpression("onmouseover", onmouseover);
      } else {
        command.getAttributes().put("onmouseover", onmouseover.getExpressionString());
      }
    }
    if (onmouseup != null) {
      if (!onmouseup.isLiteralText()) {
        command.setValueExpression("onmouseup", onmouseup);
      } else {
        command.getAttributes().put("onmouseup", onmouseup.getExpressionString());
      }
    }
    if (style != null) {
      if (!style.isLiteralText()) {
        command.setValueExpression("style", style);
      } else {
        command.getAttributes().put("style", style.getExpressionString());
      }
    }
    if (styleClass != null) {
      if (!styleClass.isLiteralText()) {
        command.setValueExpression("styleClass", styleClass);
      } else {
        command.getAttributes().put("styleClass", styleClass.getExpressionString());
      }
    }
    if (type != null) {
      if (!type.isLiteralText()) {
        command.setValueExpression("type", type);
      } else {
        command.getAttributes().put("type", type.getExpressionString());
      }
    }
    if (value != null) {
      if (!value.isLiteralText()) {
        command.setValueExpression("value", value);
      } else {
        command.setValue(value.getExpressionString());
      }
    }
  }
コード例 #12
0
  protected void setProperties(UIComponent component) {
    super.setProperties(component);
    javax.faces.component.UIPanel panel = null;
    try {
      panel = (javax.faces.component.UIPanel) component;
    } catch (ClassCastException cce) {
      throw new IllegalStateException(
          "Component "
              + component.toString()
              + " not expected type.  Expected: javax.faces.component.UIPanel.  Perhaps you're missing a tag?");
    }

    if (bgcolor != null) {
      if (!bgcolor.isLiteralText()) {
        panel.setValueExpression("bgcolor", bgcolor);
      } else {
        panel.getAttributes().put("bgcolor", bgcolor.getExpressionString());
      }
    }
    if (border != null) {
      if (!border.isLiteralText()) {
        panel.setValueExpression("border", border);
      } else {
        panel
            .getAttributes()
            .put("border", java.lang.Integer.valueOf(border.getExpressionString()));
      }
    }
    if (columnClasses != null) {
      if (!columnClasses.isLiteralText()) {
        panel.setValueExpression("columnClasses", columnClasses);
      } else {
        panel.getAttributes().put("columnClasses", columnClasses.getExpressionString());
      }
    }
    if (columns != null) {
      if (!columns.isLiteralText()) {
        panel.setValueExpression("columns", columns);
      } else {
        panel
            .getAttributes()
            .put("columns", java.lang.Integer.valueOf(columns.getExpressionString()));
      }
    }
    if (onclick != null) {
      if (!onclick.isLiteralText()) {
        panel.setValueExpression("onclick", onclick);
      } else {
        panel.getAttributes().put("onclick", onclick.getExpressionString());
      }
    }
    if (ondblclick != null) {
      if (!ondblclick.isLiteralText()) {
        panel.setValueExpression("ondblclick", ondblclick);
      } else {
        panel.getAttributes().put("ondblclick", ondblclick.getExpressionString());
      }
    }
    if (onkeydown != null) {
      if (!onkeydown.isLiteralText()) {
        panel.setValueExpression("onkeydown", onkeydown);
      } else {
        panel.getAttributes().put("onkeydown", onkeydown.getExpressionString());
      }
    }
    if (onkeypress != null) {
      if (!onkeypress.isLiteralText()) {
        panel.setValueExpression("onkeypress", onkeypress);
      } else {
        panel.getAttributes().put("onkeypress", onkeypress.getExpressionString());
      }
    }
    if (onkeyup != null) {
      if (!onkeyup.isLiteralText()) {
        panel.setValueExpression("onkeyup", onkeyup);
      } else {
        panel.getAttributes().put("onkeyup", onkeyup.getExpressionString());
      }
    }
    if (onmousedown != null) {
      if (!onmousedown.isLiteralText()) {
        panel.setValueExpression("onmousedown", onmousedown);
      } else {
        panel.getAttributes().put("onmousedown", onmousedown.getExpressionString());
      }
    }
    if (onmousemove != null) {
      if (!onmousemove.isLiteralText()) {
        panel.setValueExpression("onmousemove", onmousemove);
      } else {
        panel.getAttributes().put("onmousemove", onmousemove.getExpressionString());
      }
    }
    if (onmouseout != null) {
      if (!onmouseout.isLiteralText()) {
        panel.setValueExpression("onmouseout", onmouseout);
      } else {
        panel.getAttributes().put("onmouseout", onmouseout.getExpressionString());
      }
    }
    if (onmouseover != null) {
      if (!onmouseover.isLiteralText()) {
        panel.setValueExpression("onmouseover", onmouseover);
      } else {
        panel.getAttributes().put("onmouseover", onmouseover.getExpressionString());
      }
    }
    if (onmouseup != null) {
      if (!onmouseup.isLiteralText()) {
        panel.setValueExpression("onmouseup", onmouseup);
      } else {
        panel.getAttributes().put("onmouseup", onmouseup.getExpressionString());
      }
    }
    if (rowClasses != null) {
      if (!rowClasses.isLiteralText()) {
        panel.setValueExpression("rowClasses", rowClasses);
      } else {
        panel.getAttributes().put("rowClasses", rowClasses.getExpressionString());
      }
    }
    if (style != null) {
      if (!style.isLiteralText()) {
        panel.setValueExpression("style", style);
      } else {
        panel.getAttributes().put("style", style.getExpressionString());
      }
    }
    if (styleClass != null) {
      if (!styleClass.isLiteralText()) {
        panel.setValueExpression("styleClass", styleClass);
      } else {
        panel.getAttributes().put("styleClass", styleClass.getExpressionString());
      }
    }
  }
コード例 #13
0
 @Override
 public String getExpressionString() {
   return originalValueExpression.getExpressionString();
 }
コード例 #14
0
ファイル: BeanValidator.java プロジェクト: juangon/mojarra
  /**
   * <span class="changed_modified_2_3">Verify</span> that the value is valid according to the Bean
   * Validation constraints. <div class="changed_added_2_0">
   *
   * <p>Obtain a {@link ValidatorFactory} instance by calling {@link
   * javax.validation.Validation#buildDefaultValidatorFactory}.
   *
   * <p>Let <em>validationGroupsArray</em> be a <code>Class []</code> representing validator groups
   * set on the component by the tag handler for this validator. The first search component
   * terminates the search for the validation groups value. If no such value is found use the class
   * name of {@link javax.validation.groups.Default} as the value of the validation groups.
   *
   * <p>Let <em>valueExpression</em> be the return from calling {@link
   * UIComponent#getValueExpression} on the argument <em>component</em>, passing the literal string
   * &#8220;value&#8221; (without the quotes) as an argument. If this application is running in an
   * environment with a Unified EL Implementation for Java EE6 or later, obtain the <code>
   * ValueReference</code> from <em>valueExpression</em> and let <em>valueBaseClase</em> be the
   * return from calling <code>ValueReference.getBase()</code> and <em>valueProperty</em> be the
   * return from calling <code>ValueReference.getProperty()</code>. If an earlier version of the
   * Unified EL is present, use the appropriate methods to inspect <em>valueExpression</em> and
   * derive values for <em>valueBaseClass</em> and <em>valueProperty</em>.
   *
   * <p>If no <code>ValueReference</code> can be obtained, take no action and return.
   *
   * <p>If <code>ValueReference.getBase()</code> return <code>null</code>, take no action and
   * return.
   *
   * <p>Obtain the {@link ValidatorContext} from the {@link ValidatorFactory}.
   *
   * <p>Decorate the {@link MessageInterpolator} returned from {@link
   * ValidatorFactory#getMessageInterpolator} with one that leverages the <code>Locale</code>
   * returned from {@link javax.faces.component.UIViewRoot#getLocale}, and store it in the <code>
   * ValidatorContext</code> using {@link ValidatorContext#messageInterpolator}.
   *
   * <p>Obtain the {@link javax.validation.Validator} instance from the <code>validatorContext
   * </code>.
   *
   * <p>Obtain a <code>javax.validation.BeanDescriptor</code> from the <code>
   * javax.validation.Validator</code>. If <code>hasConstraints()</code> on the <code>BeanDescriptor
   * </code> returns false, take no action and return. Otherwise proceed.
   *
   * <p>Call {@link javax.validation.Validator#validateValue}, passing <em>valueBaseClass</em>,
   * <em>valueProperty</em>, the <em>value</em> argument, and <em>validatorGroupsArray</em> as
   * arguments.
   *
   * <p>If the returned <code>Set&lt;{@link
   * ConstraintViolation}&gt;</code> is non-empty, for each element in the <code>Set</code>, create
   * a {@link FacesMessage} where the summary and detail are the return from calling {@link
   * ConstraintViolation#getMessage}. Capture all such <code>FacesMessage</code> instances into a
   * <code>Collection</code> and pass them to {@link
   * ValidatorException#ValidatorException(java.util.Collection)}. <span
   * class="changed_added_2_3">If the {@link #ENABLE_VALIDATE_WHOLE_BEAN_PARAM_NAME} application
   * parameter is enabled and this {@code Validator} instance has validation groups other than or in
   * addition to the {@code Default} group, record the fact that this field failed validation so
   * that any <code>&lt;f:validateWholeBean /&gt;</code> component later in the tree is able to skip
   * class-level validation for the bean for which this particular field is a property. Regardless
   * of whether or not {@link #ENABLE_VALIDATE_WHOLE_BEAN_PARAM_NAME} is set, throw the new
   * exception.</span>
   *
   * <p class="changed_added_2_3">If the returned {@code Set} is empty, the {@link
   * #ENABLE_VALIDATE_WHOLE_BEAN_PARAM_NAME} application parameter is enabled and this {@code
   * Validator} instance has validation groups other than or in addition to the {@code Default}
   * group, record the fact that this field passed validation so that any <code>
   * &lt;f:validateWholeBean /&gt;</code> component later in the tree is able to allow class-level
   * validation for the bean for which this particular field is a property. </div>
   *
   * @param context {@inheritDoc}
   * @param component {@inheritDoc}
   * @param value {@inheritDoc}
   * @throws ValidatorException {@inheritDoc}
   */
  @Override
  public void validate(FacesContext context, UIComponent component, Object value) {

    if (context == null) {
      throw new NullPointerException();
    }
    if (component == null) {
      throw new NullPointerException();
    }
    ValueExpression valueExpression = component.getValueExpression("value");
    if (valueExpression == null) {
      return;
    }

    ValidatorFactory validatorFactory;
    Object cachedObject =
        context.getExternalContext().getApplicationMap().get(VALIDATOR_FACTORY_KEY);
    if (cachedObject instanceof ValidatorFactory) {
      validatorFactory = (ValidatorFactory) cachedObject;
    } else {
      try {
        validatorFactory = Validation.buildDefaultValidatorFactory();
      } catch (ValidationException e) {
        throw new FacesException("Could not build a default Bean Validator factory", e);
      }
      context.getExternalContext().getApplicationMap().put(VALIDATOR_FACTORY_KEY, validatorFactory);
    }

    ValidatorContext validatorContext = validatorFactory.usingContext();
    MessageInterpolator jsfMessageInterpolator =
        new JsfAwareMessageInterpolator(context, validatorFactory.getMessageInterpolator());
    validatorContext.messageInterpolator(jsfMessageInterpolator);
    javax.validation.Validator beanValidator = validatorContext.getValidator();
    Class[] validationGroupsArray = parseValidationGroups(getValidationGroups());

    // PENDING(rlubke, driscoll): When EL 1.3 is present, we won't need
    // this.

    ValueExpressionAnalyzer expressionAnalyzer = new ValueExpressionAnalyzer(valueExpression);

    ValueReference valueReference = expressionAnalyzer.getReference(context.getELContext());
    if (valueReference == null) {
      return;
    }
    if (isResolvable(valueReference, valueExpression)) {
      Set<ConstraintViolation<?>> violations = null;
      try {
        //noinspection unchecked
        violations =
            beanValidator.validateValue(
                valueReference.getBaseClass(),
                valueReference.getProperty(),
                value,
                validationGroupsArray);
      } catch (IllegalArgumentException iae) {
        String failureMessage =
            "Unable to validate expression "
                + valueExpression.getExpressionString()
                + " using Bean Validation.  Unable to get value of expression. "
                + " Message from Bean Validation: "
                + iae.getMessage();
        LOGGER.fine(failureMessage);
      }

      if (violations != null && !violations.isEmpty()) {
        ValidatorException toThrow;
        if (1 == violations.size()) {
          ConstraintViolation violation = violations.iterator().next();
          toThrow =
              new ValidatorException(
                  MessageFactory.getMessage(
                      context,
                      MESSAGE_ID,
                      violation.getMessage(),
                      MessageFactory.getLabel(context, component)));
        } else {
          Set<FacesMessage> messages = new LinkedHashSet<>(violations.size());
          for (ConstraintViolation violation : violations) {
            messages.add(
                MessageFactory.getMessage(
                    context,
                    MESSAGE_ID,
                    violation.getMessage(),
                    MessageFactory.getLabel(context, component)));
          }
          toThrow = new ValidatorException(messages);
        }

        // Record the fact that this field failed validation, so that multi-field
        // validation is not attempted.
        if (MultiFieldValidationUtils.wholeBeanValidationEnabled(context, validationGroupsArray)) {
          Map<Object, Map<String, Map<String, Object>>> multiFieldCandidates =
              MultiFieldValidationUtils.getMultiFieldValidationCandidates(context, true);
          Object val = valueReference.getBase();
          Map<String, Map<String, Object>> candidate =
              multiFieldCandidates.getOrDefault(val, new HashMap<>());
          Map<String, Object> tuple = new HashMap<>();
          tuple.put("component", component);
          tuple.put("value", FAILED_FIELD_LEVEL_VALIDATION);
          candidate.put(valueReference.getProperty(), tuple);
          multiFieldCandidates.putIfAbsent(val, candidate);
        }

        throw toThrow;
      }
    }

    // Record the fact that this field passed validation, so that multi-field
    // validation can be performed if desired
    if (MultiFieldValidationUtils.wholeBeanValidationEnabled(context, validationGroupsArray)) {
      Map<Object, Map<String, Map<String, Object>>> multiFieldCandidates =
          MultiFieldValidationUtils.getMultiFieldValidationCandidates(context, true);
      Object val = valueReference.getBase();
      Map<String, Map<String, Object>> candidate =
          multiFieldCandidates.getOrDefault(val, new HashMap<>());
      Map<String, Object> tuple =
          new HashMap<>(); // new ComponentValueTuple((EditableValueHolder) component, value);
      tuple.put("component", component);
      tuple.put("value", value);
      candidate.put(valueReference.getProperty(), tuple);
      multiFieldCandidates.putIfAbsent(val, candidate);
    }
  }
コード例 #15
0
ファイル: LifecycleImpl.java プロジェクト: dlitz/resin
  private void printComponentTree(
      PrintWriter out, String errorId, FacesContext context, UIComponent comp, int depth) {
    for (int i = 0; i < depth; i++) out.print(' ');

    boolean isError = false;
    if (errorId != null && errorId.equals(comp.getClientId(context))) {
      isError = true;
      out.print("<span style='color:red'>");
    }

    out.print("&lt;" + comp.getClass().getSimpleName());
    if (comp.getId() != null) out.print(" id=\"" + comp.getId() + "\"");

    for (Method method : comp.getClass().getMethods()) {
      if (!method.getName().startsWith("get") && !method.getName().startsWith("is")) continue;
      else if (method.getParameterTypes().length != 0) continue;

      String name;

      if (method.getName().startsWith("get")) name = method.getName().substring(3);
      else if (method.getName().startsWith("is")) name = method.getName().substring(2);
      else continue;

      // XXX: getURL
      name = Character.toLowerCase(name.charAt(0)) + name.substring(1);

      ValueExpression expr = comp.getValueExpression(name);

      Class type = method.getReturnType();

      if (expr != null) {
        out.print(" " + name + "=\"" + expr.getExpressionString() + "\"");
      } else if (method.getDeclaringClass().equals(UIComponent.class)
          || method.getDeclaringClass().equals(UIComponentBase.class)) {
      } else if (name.equals("family")) {
      } else if (String.class.equals(type)) {
        try {
          Object value = method.invoke(comp);

          if (value != null) out.print(" " + name + "=\"" + value + "\"");
        } catch (Exception e) {
        }
      }
    }

    int facetCount = comp.getFacetCount();
    int childCount = comp.getChildCount();

    if (facetCount == 0 && childCount == 0) {
      out.print("/>");

      if (isError) out.print("</span>");

      out.println();
      return;
    }
    out.println(">");

    if (isError) out.print("</span>");

    for (int i = 0; i < childCount; i++) {
      printComponentTree(out, errorId, context, comp.getChildren().get(i), depth + 1);
    }

    for (int i = 0; i < depth; i++) out.print(' ');

    if (isError) out.print("<span style='color:red'>");

    out.println("&lt;/" + comp.getClass().getSimpleName() + ">");

    if (isError) out.print("</span>");
  }
コード例 #16
0
 static String save(ValueExpression expr, FacesContext context) {
   if (expr != null) return expr.getExpressionString();
   else return null;
 }
コード例 #17
0
ファイル: ComponentUtils.java プロジェクト: shanmuka/icefaces
 /**
  * Attempts to return the property accessed in a simple EL expression of the form
  * ${someObject.property}.
  *
  * @param expression An EL expression to parse the property from.
  * @return The property name of the EL expression.
  */
 public static String resolveField(ValueExpression expression) {
   String expressionString = expression.getExpressionString();
   return expressionString.substring(
       expressionString.indexOf(".") + 1, expressionString.length() - 1);
 }
コード例 #18
0
 @Override
 public String toString() {
   return expression.getExpressionString();
 }