Exemplo n.º 1
0
  public static void add(Composable source, Composable target, double mnoznik) {

    BeanWrapper wrapperSource = new BeanWrapperImpl(source);
    BeanWrapper wrapperTarget = new BeanWrapperImpl(target);

    for (int i = 0; i < wrapperSource.getPropertyDescriptors().length; ++i) {

      String propName = wrapperSource.getPropertyDescriptors()[i].getName();

      if (wrapperSource.isReadableProperty(propName)) {
        Object propValue = wrapperSource.getPropertyValue(propName);

        if (propValue != null) {

          if (propValue instanceof Composable) {
            if ((Composable) wrapperTarget.getPropertyValue(propName) == null)
              System.out.println(propName);
            add(
                (Composable) propValue,
                (Composable) wrapperTarget.getPropertyValue(propName),
                mnoznik);
          } else if (propValue instanceof Double) {
            if (wrapperTarget.getPropertyValue(propName) == null)
              wrapperTarget.setPropertyValue(propName, 0.0);
            wrapperTarget.setPropertyValue(
                propName,
                ((Double) wrapperTarget.getPropertyValue(propName)) + mnoznik * (Double) propValue);
          }
        }
      }
    }
  }
Exemplo n.º 2
0
  /**
   * Find all occurrences of targetClass in targetObject. Be careful. This stuff may be recursive !
   * Should be improved to prevent endless recursive loops.
   *
   * @param
   * @return
   * @param targetObject
   * @param targetClass
   * @param nestedPath
   * @return
   * @throws Exception
   */
  public static Map<String, ?> findNestedPaths(
      Object targetObject,
      Class<?> targetClass,
      String nestedPath,
      List<String> ignoreList,
      Set<Object> visited,
      int maxDepth)
      throws Exception {

    Assert.notNull(targetObject);
    Assert.notNull(targetClass);
    Assert.notNull(ignoreList);
    HashMap<String, Object> nestedPaths = new HashMap<String, Object>();
    if (maxDepth <= 0) {
      return nestedPaths;
    }

    nestedPath = (nestedPath == null ? "" : nestedPath);
    BeanWrapper bw = PropertyAccessorFactory.forBeanPropertyAccess(targetObject);
    PropertyDescriptor[] props = bw.getPropertyDescriptors();

    for (PropertyDescriptor pd : props) {
      Class<?> clazz = pd.getPropertyType();
      if (clazz != null
          && !clazz.equals(Class.class)
          && !clazz.isAnnotation()
          && !clazz.isPrimitive()) {
        Object value = null;
        String pathName = pd.getName();
        if (!ignoreList.contains(pathName)) {
          try {
            value = bw.getPropertyValue(pathName);
          } catch (Exception e) {
          } // ignore any exceptions here
          if (StringUtils.hasText(nestedPath)) {
            pathName = nestedPath + PropertyAccessor.NESTED_PROPERTY_SEPARATOR + pathName;
          }
          // TODO break up this stuff into checking and excecution a la ReflectionUtils
          if (targetClass.isAssignableFrom(clazz)) {
            nestedPaths.put(pathName, value);
          }
          // exclude objects already visited from further inspection to prevent circular references
          // unfortunately this stuff isn't fool proof as there are ConcurrentModificationExceptions
          // when adding objects to the visited list
          if (value != null && !isInstanceVisited(visited, value)) {
            nestedPaths.putAll(
                findNestedPaths(value, targetClass, pathName, ignoreList, visited, maxDepth - 1));
          }
        }
      }
    }
    return nestedPaths;
  }
Exemplo n.º 3
0
  private void copyBoundProperties(User src, User dst) {
    BeanWrapper srcW = new BeanWrapperImpl(src);
    BeanWrapper dstW = new BeanWrapperImpl(dst);

    for (PropertyDescriptor srcProp : srcW.getPropertyDescriptors()) {
      if (srcProp.getReadMethod() == null || srcProp.getWriteMethod() == null) {
        continue;
      }
      Object srcValue = srcW.getPropertyValue(srcProp.getName());
      if (srcValue != null) {
        dstW.setPropertyValue(srcProp.getName(), srcValue);
      }
    }
  }
Exemplo n.º 4
0
  protected void init(Object entity) {
    this.entity = entity;

    beanWrapper = PropertyAccessorFactory.forBeanPropertyAccess(entity);
    PropertyDescriptor[] descriptors = beanWrapper.getPropertyDescriptors();
    if (descriptors.length > 1) {
      for (PropertyDescriptor descriptor : descriptors) {
        if (beanWrapper.isReadableProperty(descriptor.getName())) {
          privateFields.add(descriptor.getName());
        }
      }
    }

    Field[] fields = BeanFields.get(entity.getClass());
    if (fields != null) {
      for (Field field : fields) {
        publicFeilds.put(field.getName(), field);
      }
    }
  }
Exemplo n.º 5
0
  /** Bind controls following the same name convention or annotated with Property annotation. */
  public void autobind() {
    BeanWrapper bw = PropertyAccessorFactory.forBeanPropertyAccess(getModel());
    PropertyAccessor viewPropertyAccessor = new DirectFieldAccessor(this);

    // Parse Property annotations
    List<AnnotatedElement> elements =
        AnnotatedElementAccessor.findAnnotatedElements(Property.class, getClass());

    for (AnnotatedElement ae : elements) {
      Property p = ae.getAnnotation(Property.class);
      InitializationConfig config = getInitializationConfig(ae.getAnnotation(Initializer.class));
      bindAndInitializeControl(
          p.value(), viewPropertyAccessor.getPropertyValue(((Field) ae).getName()), config);
      this.ignoredProperties.add(p.value());
    }

    // Iterate on model properties
    for (PropertyDescriptor pd : bw.getPropertyDescriptors()) {
      String propertyName = pd.getName();
      if (!ignoredProperties.contains(propertyName)
          && viewPropertyAccessor.isReadableProperty(propertyName)) {
        Object control = viewPropertyAccessor.getPropertyValue(propertyName);

        if (control != null) {
          if (log.isDebugEnabled())
            log.debug(
                "Found control: "
                    + control.getClass().getSimpleName()
                    + " for property: "
                    + propertyName);
          TypeDescriptor descriptor = viewPropertyAccessor.getPropertyTypeDescriptor(propertyName);
          InitializationConfig config =
              getInitializationConfig(descriptor.getAnnotation(Initializer.class));
          // do bind
          bindAndInitializeControl(propertyName, control, config);
        }
      }
    }
  }
Exemplo n.º 6
0
  @Override
  public UserProfile getProfileForDisplay(UserProfile userProfile, boolean showPrivateFields) {
    UserProfile display = new UserProfile();
    copyFields(userProfile, display);
    if (!showPrivateFields) {
      log.debug("Removing private fields for display on user: {}", userProfile.getDisplayName());
      display.setOrganizationName(null);
      display.setOrganizationType(null);
      display.setPostalAddress(null);
      display.setPositionType(null);
    }

    // escape html in all string fields
    BeanWrapper wrapper = new BeanWrapperImpl(display);
    for (PropertyDescriptor property : wrapper.getPropertyDescriptors()) {
      if (String.class.isAssignableFrom(property.getPropertyType())) {
        String name = property.getName();
        wrapper.setPropertyValue(
            name, TextUtils.escapeHtml((String) wrapper.getPropertyValue(name)));
      }
    }

    return display;
  }
Exemplo n.º 7
0
  private static void assertDepthEquals(
      final int depth, final String propertyName, final Object expected, Object actual) {
    if (expected == null && actual == null) {
      return;
    } else if (expected == null) {
      fail("expected " + propertyName + " was null but actual was not!");
    } else if (actual == null) {
      fail("actual " + propertyName + " was null but expected was not!");
    }

    final String assertionMessage =
        propertyName == null
            ? ("Top-level objects (" + expected.getClass().getName() + ") do not match.")
            : ("Properties " + propertyName + " do not match.");
    if (expected.getClass().getName().startsWith("java")
        || actual.getClass().getName().startsWith("java")) {
      // java primitives, just do assertEquals
      if (expected instanceof Object[] || actual instanceof Object[]) {
        assertTrue(assertionMessage, Arrays.equals((Object[]) expected, (Object[]) actual));
      } else {
        assertEquals(assertionMessage, expected, actual);
      }
      return;
    }

    final BeanWrapper expectedWrapper = new BeanWrapperImpl(expected);
    final BeanWrapper actualWrapper = new BeanWrapperImpl(actual);

    final Set<String> properties = new TreeSet<String>();
    for (final PropertyDescriptor descriptor : expectedWrapper.getPropertyDescriptors()) {
      properties.add(descriptor.getName());
    }
    for (final PropertyDescriptor descriptor : actualWrapper.getPropertyDescriptors()) {
      properties.add(descriptor.getName());
    }

    properties.remove("class");

    for (final String property : properties) {
      final PropertyDescriptor expectedDescriptor = expectedWrapper.getPropertyDescriptor(property);
      final PropertyDescriptor actualDescriptor = actualWrapper.getPropertyDescriptor(property);

      if (expectedDescriptor != null && actualDescriptor != null) {
        // both have descriptors, so walk the sub-objects
        Object expectedValue = null;
        Object actualValue = null;
        try {
          expectedValue = expectedWrapper.getPropertyValue(property);
        } catch (final Exception e) {
        }
        try {
          actualValue = actualWrapper.getPropertyValue(property);
        } catch (final Exception e) {
        }

        assertDepthEquals(depth + 1, property, expectedValue, actualValue);
      } else if (expectedDescriptor != null) {
        fail("Should have '" + property + "' property on actual object, but there was none!");
      } else if (actualDescriptor != null) {
        fail("Should have '" + property + "' property on expected object, but there was none!");
      }
    }

    if (expected instanceof Object[] || actual instanceof Object[]) {
      final Object[] expectedArray = (Object[]) expected;
      final Object[] actualArray = (Object[]) actual;
      assertTrue(assertionMessage, Arrays.equals(expectedArray, actualArray));
    } else {
      assertEquals(assertionMessage, expected, actual);
    }
  }