private Boolean callMethod(String attributeName, Object parentObj, Map<String, String> values) {
    if (logger.isTraceEnabled()) {
      logger.trace(
          ">>> callMethod attributeName="
              + attributeName
              + ", parentObj="
              + parentObj
              + ", values="
              + values);
    }

    if (attributeName == null || parentObj == null || values == null) return null;
    String methodName = values.get(MODIFIER_CALL);
    if (methodName == null) return null;
    Object result = null;
    try {
      result = MethodUtils.invokeMethod(parentObj, methodName, attributeName);
    } catch (NoSuchMethodException e) {
      return null;
    } catch (IllegalAccessException e) {
      throw new RuntimeException(e);
    } catch (InvocationTargetException e) {
      throw new RuntimeException(e);
    }
    if (result == null || !(result instanceof Boolean)) {
      return null;
    }
    return (Boolean) result;
  }
  public BufferedImage decodeAsBufferedImage(InputStream input) throws Exception {
    if (jpegCodecClazz == null) {
      jpegCodecClazz = Class.forName("com.sun.image.codec.jpeg.JPEGCodec");
    }

    Object decoder = MethodUtils.invokeStaticMethod(jpegCodecClazz, "createJPEGDecoder", input);

    return (BufferedImage) MethodUtils.invokeMethod(decoder, "decodeAsBufferedImage", null);
  }
  /**
   * Used for the evaluation of the emptiness in the META SQL fragments.
   *
   * @param attributeName the name of the input value
   * @param obj the input value
   * @param parentObj the parent of the input value
   * @param sqlMetaType the internal type (= META type) devoted for the special processing of the
   *     input values
   * @param inOutModifier the input/output value modifier devoted to extend the processing of the
   *     input/output values
   * @param inSqlSetOrInsert an indicator the input value is evaluated in the CRUD statement (INSERT
   *     or SET)
   * @param values values for a special identifier handling, for example a sequence for an identity
   * @param features the optional features in the statement coontext
   * @return the non-emptiness of the input value
   */
  protected boolean isNotEmptyInternal(
      String attributeName,
      Object obj,
      Object parentObj,
      SqlMetaType sqlMetaType,
      String inOutModifier,
      boolean inSqlSetOrInsert,
      Map<String, String> values,
      Map<String, Object> features)
      throws IllegalArgumentException {

    if (MODIFIER_NOTNULL.equalsIgnoreCase(inOutModifier)) {
      if (obj == null) throw new IllegalArgumentException(MODIFIER_NOTNULL);
    }

    if (inSqlSetOrInsert) {
      boolean isEmptyUseMethodIsNull = false;
      if (obj == null && attributeName != null && parentObj != null) {
        Object o = features.get(SqlFeature.EMPTY_USE_METHOD_IS_NULL);
        if (o != null && o instanceof Boolean && ((Boolean) o)) isEmptyUseMethodIsNull = true;
      }
      Object isNullObj = null;
      if (isEmptyUseMethodIsNull) {
        try {
          isNullObj = MethodUtils.invokeMethod(parentObj, "isNull", attributeName);
        } catch (NoSuchMethodException e) {
        } catch (IllegalAccessException e) {
          throw new RuntimeException(e);
        } catch (InvocationTargetException e) {
          throw new RuntimeException(e);
        }
      }
      if (isNullObj != null && isNullObj instanceof Boolean && ((Boolean) isNullObj)) {
        return true;
      }
      boolean isEmptyForNull = isEmptyUseMethodIsNull;
      if (isEmpty(obj, values)) {
        Object o = features.get(SqlFeature.EMPTY_FOR_NULL);
        if (o != null && o instanceof Boolean && ((Boolean) o)) isEmptyForNull = true;
        if (!isEmptyForNull) return true;
      }
    }

    if (MODIFIER_ANY.equalsIgnoreCase(inOutModifier)) {
      return true;
    } else if (MODIFIER_NULL.equalsIgnoreCase(inOutModifier)) {
      if (obj == null) return true;
      else return false;
    } else {
      return !isEmpty(obj, values);
    }
  }
Example #4
0
 public void invoke(String method) {
   if (method != null && method.trim().length() > 0) {
     try {
       Object o = MethodUtils.invokeMethod(getController(), method, null);
       if (o != null) {
         if (o instanceof String) {
           String p = (String) o;
           setCurrentPage(p);
         }
       }
       if (getCurrentPage() == null) {
         setCurrentPage("default");
       }
     } catch (Exception ex) {
       throw new IllegalStateException(ex.getMessage(), ex);
     }
   }
 }
Example #5
0
  protected void populateDataFromManager(
      Object executionClass, WebDropDownListIF methodName, ModelAndView modelview, Map extraParams)
      throws ApplicationCoreException {

    StringBuilder methodNameStr = new StringBuilder();
    methodNameStr.append(REF_DATA_PREFIX);
    methodNameStr.append(StringUtil.makeFirstLetterUpperCase(methodName.toString()));

    Object[] params = {methodName.toString(), modelview, extraParams};

    try {
      Map returnValues =
          (Map) MethodUtils.invokeMethod(executionClass, methodNameStr.toString(), params);
      modelview.addObject(methodName.toString(), returnValues);

    } catch (NoSuchMethodException e) {
      logger.warn("Invalid method on the web data source during population.");
    } catch (IllegalAccessException e) {
      throw new ApplicationCoreException(e);
    } catch (InvocationTargetException e) {
      logger.warn("Invalid method on the web data source during population.");
    }
  }
  /** {@inheritDoc} */
  @Override
  public Requisition deletePath(final String groupName, final String pathToDelete) {
    m_writeLock.lock();

    try {
      final Requisition group = getProvisioningGroup(groupName);

      final PropertyPath path = new PropertyPath(pathToDelete);

      final Object objToDelete = path.getValue(group);
      final Object parentObject =
          path.getParent() == null ? group : path.getParent().getValue(group);

      final String propName = path.getPropertyName();
      final String methodSuffix = Character.toUpperCase(propName.charAt(0)) + propName.substring(1);
      final String methodName = "delete" + methodSuffix;

      try {
        MethodUtils.invokeMethod(parentObject, methodName, new Object[] {objToDelete});
      } catch (final NoSuchMethodException e) {
        throw new IllegalArgumentException(
            "Unable to find method " + methodName + " on object of type " + parentObject.getClass(),
            e);
      } catch (final IllegalAccessException e) {
        throw new IllegalArgumentException("unable to access property " + pathToDelete, e);
      } catch (final InvocationTargetException e) {
        throw new IllegalArgumentException("an execption occurred deleting " + pathToDelete, e);
      }

      m_pendingForeignSourceRepository.save(group);
      m_pendingForeignSourceRepository.flush();
      return m_pendingForeignSourceRepository.getRequisition(groupName);
    } finally {
      m_writeLock.unlock();
    }
  }
 /**
  * Invoke the method. NOTE: MethodUtils doesn't support primitive arguments. e.g) echo(long[] v)
  */
 public static Object invokeMethod(Object obj, String methodName, Object[] arguments)
     throws NoSuchMethodException, IllegalAccessException, InvocationTargetException {
   return MethodUtils.invokeMethod(obj, methodName, arguments);
 }