Exemple #1
0
    public <T> TypeAdapter<T> create(Gson gson, TypeToken<T> type) {

      @SuppressWarnings("unchecked")
      Class<T> rawType = (Class<T>) type.getRawType();
      if (!rawType.isEnum()) {
        return null;
      }

      final Map<String, T> lowercaseToConstant = new HashMap<String, T>();
      for (T constant : rawType.getEnumConstants()) {
        lowercaseToConstant.put(toLowercase(constant), constant);
      }

      return new TypeAdapter<T>() {
        public void write(JsonWriter out, T value) throws IOException {
          if (value == null) {
            out.nullValue();
          } else {
            out.value(toLowercase(value));
          }
        }

        public T read(JsonReader reader) throws IOException {
          if (reader.peek() == JsonToken.NULL) {
            reader.nextNull();
            return null;
          } else {
            return lowercaseToConstant.get(reader.nextString());
          }
        }
      };
    }
Exemple #2
0
 protected T blankInstance() {
   try {
     return backedType.newInstance();
   } catch (Exception e) {
     throw new RuntimeException(
         "Cannot instantiate " + backedType + ". It must have a default constructor", e);
   }
 }
  private static <T> T mapToClazz(Map<String, String> map, Class<T> clazz, String formatStr)
      throws InstantiationException, IllegalAccessException, InvocationTargetException {
    Map<String, String> mapdata = getCaseInsensitveMap(map);
    T paypalClassicResponseModel;
    paypalClassicResponseModel = clazz.newInstance();
    for (Field field : FieldUtils.getAllFields(clazz)) {
      if (String.class.isAssignableFrom(field.getType())) {
        BeanUtils.setProperty(
            paypalClassicResponseModel,
            field.getName(),
            mapdata.get(getFormatedKeyName(formatStr, field.getName(), null)));
      }

      if (List.class.isAssignableFrom(field.getType())) {
        PaypalCollection paypalCollection = field.getAnnotation(PaypalCollection.class);
        ParameterizedType ty = ((ParameterizedType) field.getGenericType());
        if (ty.getActualTypeArguments()[0] instanceof Class) {
          Class subClazz = (Class<?>) ty.getActualTypeArguments()[0];
          if (String.class.isAssignableFrom(subClazz)) {
            if (paypalCollection != null && StringUtils.isNotEmpty(paypalCollection.format())) {
              List<String> values =
                  fetchPartialKey(
                      mapdata,
                      getFormatedKeyName(paypalCollection.format(), field.getName(), null));
              BeanUtils.setProperty(paypalClassicResponseModel, field.getName(), values);
            } else {
              List<String> values = fetchPartialKey(mapdata, field.getName().toUpperCase());
              BeanUtils.setProperty(paypalClassicResponseModel, field.getName(), values);
            }
          }
          if (PaypalClassicModel.class.isAssignableFrom(subClazz)) {
            if (paypalCollection != null && StringUtils.isNotEmpty(paypalCollection.format())) {
              BeanUtils.setProperty(
                  paypalClassicResponseModel,
                  field.getName(),
                  mapToClazzList(mapdata, subClazz, paypalCollection.format()));
            }
          }
        }
      }
      if (PaypalClassicModel.class.isAssignableFrom(field.getType())) {
        BeanUtils.setProperty(
            paypalClassicResponseModel, field.getName(), mapToClazz(mapdata, field.getType()));
      }
    }
    return paypalClassicResponseModel;
  }
Exemple #4
0
  /**
   * Retrieve a field.
   *
   * @param key field name
   * @return the field (even if the field does not exist you get a field)
   */
  public Field field(String key) {

    // Value
    String fieldValue = null;
    if (data.containsKey(key)) {
      fieldValue = data.get(key);
    } else {
      if (value.isPresent()) {
        BeanWrapper beanWrapper = new BeanWrapperImpl(value.get());
        beanWrapper.setAutoGrowNestedPaths(true);
        String objectKey = key;
        if (rootName != null && key.startsWith(rootName + ".")) {
          objectKey = key.substring(rootName.length() + 1);
        }
        if (beanWrapper.isReadableProperty(objectKey)) {
          Object oValue = beanWrapper.getPropertyValue(objectKey);
          if (oValue != null) {
            final String objectKeyFinal = objectKey;
            fieldValue =
                withRequestLocale(
                    () ->
                        formatters.print(
                            beanWrapper.getPropertyTypeDescriptor(objectKeyFinal), oValue));
          }
        }
      }
    }

    // Error
    List<ValidationError> fieldErrors = errors.get(key);
    if (fieldErrors == null) {
      fieldErrors = new ArrayList<>();
    }

    // Format
    Tuple<String, List<Object>> format = null;
    BeanWrapper beanWrapper = new BeanWrapperImpl(blankInstance());
    beanWrapper.setAutoGrowNestedPaths(true);
    try {
      for (Annotation a : beanWrapper.getPropertyTypeDescriptor(key).getAnnotations()) {
        Class<?> annotationType = a.annotationType();
        if (annotationType.isAnnotationPresent(play.data.Form.Display.class)) {
          play.data.Form.Display d = annotationType.getAnnotation(play.data.Form.Display.class);
          if (d.name().startsWith("format.")) {
            List<Object> attributes = new ArrayList<>();
            for (String attr : d.attributes()) {
              Object attrValue = null;
              try {
                attrValue = a.getClass().getDeclaredMethod(attr).invoke(a);
              } catch (Exception e) {
                // do nothing
              }
              attributes.add(attrValue);
            }
            format = Tuple(d.name(), attributes);
          }
        }
      }
    } catch (NullPointerException e) {
      // do nothing
    }

    // Constraints
    List<Tuple<String, List<Object>>> constraints = new ArrayList<>();
    Class<?> classType = backedType;
    String leafKey = key;
    if (rootName != null && leafKey.startsWith(rootName + ".")) {
      leafKey = leafKey.substring(rootName.length() + 1);
    }
    int p = leafKey.lastIndexOf('.');
    if (p > 0) {
      classType = beanWrapper.getPropertyType(leafKey.substring(0, p));
      leafKey = leafKey.substring(p + 1);
    }
    if (classType != null) {
      BeanDescriptor beanDescriptor =
          play.data.validation.Validation.getValidator().getConstraintsForClass(classType);
      if (beanDescriptor != null) {
        PropertyDescriptor property = beanDescriptor.getConstraintsForProperty(leafKey);
        if (property != null) {
          constraints = Constraints.displayableConstraint(property.getConstraintDescriptors());
        }
      }
    }

    return new Field(this, key, constraints, format, fieldErrors, fieldValue);
  }