public static Map<String, String> toRequestMap(List paypalClassicModelList, String format) { Map<String, String> returnMap = new HashMap<>(); if (paypalClassicModelList != null) { for (int i = 0; i < paypalClassicModelList.size(); i++) { if (paypalClassicModelList.get(i) instanceof PaypalClassicModel) { if (StringUtils.isNoneEmpty(format)) { returnMap.putAll( toRequestMap( (PaypalClassicModel) paypalClassicModelList.get(i), format + String.valueOf(i))); } else { returnMap.putAll( toRequestMap( (PaypalClassicModel) paypalClassicModelList.get(i), String.valueOf(i))); } } if (paypalClassicModelList.get(i) instanceof List) { if (StringUtils.isNoneEmpty(format)) { returnMap.putAll( toRequestMap((List) paypalClassicModelList.get(i), format + String.valueOf(i))); } else { returnMap.putAll(toRequestMap((List) paypalClassicModelList.get(i), String.valueOf(i))); } } } } return returnMap; }
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()); } } }; }
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; }
protected Object[] getArgumentsForConstraint( String objectName, String field, ConstraintDescriptor<?> descriptor) { List<Object> arguments = new LinkedList<>(); String[] codes = new String[] {objectName + Errors.NESTED_PATH_SEPARATOR + field, field}; arguments.add(new DefaultMessageSourceResolvable(codes, field)); // Using a TreeMap for alphabetical ordering of attribute names Map<String, Object> attributesToExpose = new TreeMap<>(); for (Map.Entry<String, Object> entry : descriptor.getAttributes().entrySet()) { String attributeName = entry.getKey(); Object attributeValue = entry.getValue(); if (!internalAnnotationAttributes.contains(attributeName)) { attributesToExpose.put(attributeName, attributeValue); } } arguments.addAll(attributesToExpose.values()); return arguments.toArray(new Object[arguments.size()]); }
/** * Binds request data to this form - that is, handles form submission. * * @return a copy of this form filled with the new data */ public Form<T> bindFromRequest(Map<String, String[]> requestData, String... allowedFields) { Map<String, String> data = new HashMap<>(); for (String key : requestData.keySet()) { String[] values = requestData.get(key); if (key.endsWith("[]")) { String k = key.substring(0, key.length() - 2); for (int i = 0; i < values.length; i++) { data.put(k + "[" + i + "]", values[i]); } } else { if (values.length > 0) { data.put(key, values[0]); } } } return bind(data, allowedFields); }
private PropertyDescriptor getPropertyDescriptor(Class objClass, String property) throws IntrospectionException { synchronized (m_descriptorMapLock) { Map<String, PropertyDescriptor> propMap = m_descriptorMap.get(objClass); if (propMap == null) { propMap = new HashMap<String, PropertyDescriptor>(); m_descriptorMap.put(objClass, propMap); BeanInfo beanInfo = Introspector.getBeanInfo(objClass); PropertyDescriptor[] descriptors = beanInfo.getPropertyDescriptors(); for (PropertyDescriptor descriptor : descriptors) { propMap.put(getUnderscorePropertyName(descriptor.getName()), descriptor); } } return (propMap.get(property)); } }
private static List mapToClazzList(Map<String, String> mapdata, Class subClazz, String formatStr) throws IllegalAccessException, InstantiationException, InvocationTargetException { Map<String, String> lookupMap = getCaseInsensitveMap(mapdata); List returnList = new ArrayList(); int itemListLength = 0; // find the length of the list for (Field field : FieldUtils.getAllFields(subClazz)) { int i = 0; while (lookupMap.get(getFormatedKeyName(formatStr, field.getName(), i)) != null) { i++; } if (i > itemListLength) { itemListLength = i; } } // inital each item for (int i = 0; i < itemListLength; i++) { returnList.add(mapToClazz(lookupMap, subClazz, getFormatedKeyName(formatStr, null, i))); } return returnList; }
// Consider return map in future. private static List<String> fetchPartialKey(Map<String, String> map, String key) { List<String> keywords = Arrays.asList(key.split("\\{INDEX\\}")); List<String> listStr = new ArrayList<>(); for (Map.Entry<String, String> e : map.entrySet()) { String numStr = e.getKey().toUpperCase(); for (String keyword : keywords) { numStr = StringUtils.remove(numStr, keyword); } if (NumberUtils.isDigits(numStr)) { listStr.add(e.getValue()); } } return listStr; }
/** * 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); }
/** * Binds data to this form - that is, handles form submission. * * @param data data to submit * @return a copy of this form filled with the new data */ @SuppressWarnings("unchecked") public Form<T> bind(Map<String, String> data, String... allowedFields) { DataBinder dataBinder; Map<String, String> objectData = data; if (rootName == null) { dataBinder = new DataBinder(blankInstance()); } else { dataBinder = new DataBinder(blankInstance(), rootName); objectData = new HashMap<>(); for (String key : data.keySet()) { if (key.startsWith(rootName + ".")) { objectData.put(key.substring(rootName.length() + 1), data.get(key)); } } } if (allowedFields.length > 0) { dataBinder.setAllowedFields(allowedFields); } SpringValidatorAdapter validator = new SpringValidatorAdapter(play.data.validation.Validation.getValidator()); dataBinder.setValidator(validator); dataBinder.setConversionService(formatters.conversion); dataBinder.setAutoGrowNestedPaths(true); final Map<String, String> objectDataFinal = objectData; withRequestLocale( () -> { dataBinder.bind(new MutablePropertyValues(objectDataFinal)); return null; }); Set<ConstraintViolation<Object>> validationErrors; if (groups != null) { validationErrors = validator.validate(dataBinder.getTarget(), groups); } else { validationErrors = validator.validate(dataBinder.getTarget()); } BindingResult result = dataBinder.getBindingResult(); for (ConstraintViolation<Object> violation : validationErrors) { String field = violation.getPropertyPath().toString(); FieldError fieldError = result.getFieldError(field); if (fieldError == null || !fieldError.isBindingFailure()) { try { result.rejectValue( field, violation.getConstraintDescriptor().getAnnotation().annotationType().getSimpleName(), getArgumentsForConstraint( result.getObjectName(), field, violation.getConstraintDescriptor()), getMessageForConstraintViolation(violation)); } catch (NotReadablePropertyException ex) { throw new IllegalStateException( "JSR-303 validated property '" + field + "' does not have a corresponding accessor for data binding - " + "check your DataBinder's configuration (bean property versus direct field access)", ex); } } } if (result.hasErrors() || result.getGlobalErrorCount() > 0) { Map<String, List<ValidationError>> errors = new HashMap<>(); for (FieldError error : result.getFieldErrors()) { String key = error.getObjectName() + "." + error.getField(); if (key.startsWith("target.") && rootName == null) { key = key.substring(7); } if (!errors.containsKey(key)) { errors.put(key, new ArrayList<>()); } ValidationError validationError; if (error.isBindingFailure()) { ImmutableList.Builder<String> builder = ImmutableList.builder(); Optional<Messages> msgs = Optional.of(Http.Context.current.get()).map(c -> messagesApi.preferred(c.request())); for (String code : error.getCodes()) { code = code.replace("typeMismatch", "error.invalid"); if (!msgs.isPresent() || msgs.get().isDefinedAt(code)) { builder.add(code); } } validationError = new ValidationError( key, builder.build().reverse(), convertErrorArguments(error.getArguments())); } else { validationError = new ValidationError( key, error.getDefaultMessage(), convertErrorArguments(error.getArguments())); } errors.get(key).add(validationError); } List<ValidationError> globalErrors = new ArrayList<>(); for (ObjectError error : result.getGlobalErrors()) { globalErrors.add( new ValidationError( "", error.getDefaultMessage(), convertErrorArguments(error.getArguments()))); } if (!globalErrors.isEmpty()) { errors.put("", globalErrors); } return new Form( rootName, backedType, data, errors, Optional.empty(), groups, messagesApi, formatters); } else { Object globalError = null; if (result.getTarget() != null) { try { java.lang.reflect.Method v = result.getTarget().getClass().getMethod("validate"); globalError = v.invoke(result.getTarget()); } catch (NoSuchMethodException e) { // do nothing } catch (Throwable e) { throw new RuntimeException(e); } } if (globalError != null) { Map<String, List<ValidationError>> errors = new HashMap<>(); if (globalError instanceof String) { errors.put("", new ArrayList<>()); errors.get("").add(new ValidationError("", (String) globalError, new ArrayList())); } else if (globalError instanceof List) { for (ValidationError error : (List<ValidationError>) globalError) { List<ValidationError> errorsForKey = errors.get(error.key()); if (errorsForKey == null) { errors.put(error.key(), errorsForKey = new ArrayList<>()); } errorsForKey.add(error); } } else if (globalError instanceof Map) { errors = (Map<String, List<ValidationError>>) globalError; } return new Form( rootName, backedType, data, errors, Optional.empty(), groups, messagesApi, formatters); } return new Form( rootName, backedType, new HashMap<>(data), new HashMap<>(errors), Optional.ofNullable((T) result.getTarget()), groups, messagesApi, formatters); } }
protected Map<String, String> requestData(Http.Request request) { Map<String, String[]> urlFormEncoded = new HashMap<>(); if (request.body().asFormUrlEncoded() != null) { urlFormEncoded = request.body().asFormUrlEncoded(); } Map<String, String[]> multipartFormData = new HashMap<>(); if (request.body().asMultipartFormData() != null) { multipartFormData = request.body().asMultipartFormData().asFormUrlEncoded(); } Map<String, String> jsonData = new HashMap<>(); if (request.body().asJson() != null) { jsonData = play.libs.Scala.asJava( play.api.data.FormUtils.fromJson( "", play.api.libs.json.Json.parse( play.libs.Json.stringify(request.body().asJson())))); } Map<String, String[]> queryString = request.queryString(); Map<String, String> data = new HashMap<>(); for (String key : urlFormEncoded.keySet()) { String[] values = urlFormEncoded.get(key); if (key.endsWith("[]")) { String k = key.substring(0, key.length() - 2); for (int i = 0; i < values.length; i++) { data.put(k + "[" + i + "]", values[i]); } } else { if (values.length > 0) { data.put(key, values[0]); } } } for (String key : multipartFormData.keySet()) { String[] values = multipartFormData.get(key); if (key.endsWith("[]")) { String k = key.substring(0, key.length() - 2); for (int i = 0; i < values.length; i++) { data.put(k + "[" + i + "]", values[i]); } } else { if (values.length > 0) { data.put(key, values[0]); } } } for (String key : jsonData.keySet()) { data.put(key, jsonData.get(key)); } for (String key : queryString.keySet()) { String[] values = queryString.get(key); if (key.endsWith("[]")) { String k = key.substring(0, key.length() - 2); for (int i = 0; i < values.length; i++) { data.put(k + "[" + i + "]", values[i]); } } else { if (values.length > 0) { data.put(key, values[0]); } } } return data; }
@Override public F.Option<Product> bind(String key, Map<String, String[]> data) { return F.Option.Some(findByEan(data.get("ean")[0])); }
public static Map<String, String> toRequestMap( PaypalClassicModel paypalClassicModel, String format) { Map<String, String> returnMap = new HashMap<>(); if (paypalClassicModel == null) { return returnMap; } ValidatorFactory factory = Validation.buildDefaultValidatorFactory(); // ValidatorFactory factory = Validation.byDefaultProvider() // .configure() // .messageInterpolator( new MyMessageInterpolator() ) // .buildValidatorFactory(); Validator validator = factory.getValidator(); Set<ConstraintViolation<PaypalClassicModel>> violations = validator.validate(paypalClassicModel); if (violations.size() == 0) { try { for (Field field : FieldUtils.getAllFields(paypalClassicModel.getClass())) { if (field.getType().isAssignableFrom(String.class)) { if (BeanUtils.getProperty(paypalClassicModel, field.getName()) != null) { if (StringUtils.isNumeric(format)) { returnMap.put( field.getName().toUpperCase() + format, BeanUtils.getProperty(paypalClassicModel, field.getName())); } else { returnMap.put( getFormatedKeyName(format, field.getName(), null), BeanUtils.getProperty(paypalClassicModel, field.getName())); } } } if (PaypalClassicModel.class.isAssignableFrom(field.getType())) { if (PropertyUtils.getProperty(paypalClassicModel, field.getName()) != null) { returnMap.putAll( toRequestMap( (PaypalClassicModel) PropertyUtils.getProperty(paypalClassicModel, field.getName()), format)); } } if (List.class.isAssignableFrom(field.getType())) { List listItem = (List) PropertyUtils.getProperty(paypalClassicModel, field.getName()); if (listItem != null) { for (int i = 0; i < listItem.size(); i++) { if (listItem.get(i) instanceof PaypalClassicModel) { PaypalCollection paypalCollection = field.getAnnotation(PaypalCollection.class); if (paypalCollection != null && StringUtils.isNotEmpty(paypalCollection.format())) { String formatStr = field.getAnnotation(PaypalCollection.class).format(); returnMap.putAll( toRequestMap( (PaypalClassicModel) listItem.get(i), getFormatedKeyName(formatStr, null, i))); } else { if (StringUtils.isNoneEmpty(format)) { returnMap.putAll( toRequestMap( (PaypalClassicModel) listItem.get(i), format + String.valueOf(i))); } else { returnMap.putAll( toRequestMap((PaypalClassicModel) listItem.get(i), String.valueOf(i))); } } } if (listItem.get(i) instanceof List) { PaypalCollection paypalCollection = field.getAnnotation(PaypalCollection.class); if (paypalCollection != null && StringUtils.isNotEmpty(paypalCollection.format())) { String formatStr = field.getAnnotation(PaypalCollection.class).format(); returnMap.putAll( toRequestMap( (List) listItem.get(i), getFormatedKeyName(formatStr, null, i))); } else { if (StringUtils.isNoneEmpty(format)) { returnMap.putAll( toRequestMap((List) listItem.get(i), format + String.valueOf(i))); } else { returnMap.putAll(toRequestMap((List) listItem.get(i), String.valueOf(i))); } } } if (listItem.get(i) instanceof String) { PaypalCollection paypalCollection = field.getAnnotation(PaypalCollection.class); if (paypalCollection != null && StringUtils.isNotEmpty(paypalCollection.format())) { String formatStr = paypalCollection.format(); formatStr = getFormatedKeyName(formatStr, field.getName(), i); returnMap.put( getFormatedKeyName(format, formatStr, null), listItem.get(i).toString()); } else { returnMap.put( getFormatedKeyName(format, field.getName(), null) + i, listItem.get(i).toString()); } } } } } } } catch (IllegalAccessException e) { throw new ValidationException(e.getMessage()); } catch (InvocationTargetException e) { throw new ValidationException(e.getMessage()); } catch (NoSuchMethodException e) { throw new ValidationException(e.getMessage()); } } else { StringBuffer buf = new StringBuffer(); for (ConstraintViolation<PaypalClassicModel> violation : violations) { buf.append(violation.getMessage() + "\n"); } throw new ValidationException(buf.toString()); } return returnMap; }
private static Map<String, String> getCaseInsensitveMap(Map<String, String> map) { Map<String, String> mapdata = new TreeMap<String, String>(String.CASE_INSENSITIVE_ORDER); mapdata.putAll(map); return mapdata; }
/** * Binds data to this form - that is, handles form submission. * * @param data data to submit * @return a copy of this form filled with the new data */ public Form<T> bind(Map<String, String> data, String... allowedFields) { DataBinder dataBinder = null; Map<String, String> objectData = data; if (rootName == null) { dataBinder = new DataBinder(blankInstance()); } else { dataBinder = new DataBinder(blankInstance(), rootName); objectData = new HashMap<String, String>(); for (String key : data.keySet()) { if (key.startsWith(rootName + ".")) { objectData.put(key.substring(rootName.length() + 1), data.get(key)); } } } if (allowedFields.length > 0) { dataBinder.setAllowedFields(allowedFields); } SpringValidatorAdapter validator = new SpringValidatorAdapter(play.data.validation.Validation.getValidator()); dataBinder.setValidator(validator); dataBinder.setConversionService(play.data.format.Formatters.conversion); dataBinder.setAutoGrowNestedPaths(true); dataBinder.bind(new MutablePropertyValues(objectData)); Set<ConstraintViolation<Object>> validationErrors; if (groups != null) { validationErrors = validator.validate(dataBinder.getTarget(), groups); } else { validationErrors = validator.validate(dataBinder.getTarget()); } BindingResult result = dataBinder.getBindingResult(); for (ConstraintViolation<Object> violation : validationErrors) { String field = violation.getPropertyPath().toString(); FieldError fieldError = result.getFieldError(field); if (fieldError == null || !fieldError.isBindingFailure()) { try { result.rejectValue( field, violation.getConstraintDescriptor().getAnnotation().annotationType().getSimpleName(), getArgumentsForConstraint( result.getObjectName(), field, violation.getConstraintDescriptor()), violation.getMessage()); } catch (NotReadablePropertyException ex) { throw new IllegalStateException( "JSR-303 validated property '" + field + "' does not have a corresponding accessor for data binding - " + "check your DataBinder's configuration (bean property versus direct field access)", ex); } } } if (result.hasErrors()) { Map<String, List<ValidationError>> errors = new HashMap<String, List<ValidationError>>(); for (FieldError error : result.getFieldErrors()) { String key = error.getObjectName() + "." + error.getField(); if (key.startsWith("target.") && rootName == null) { key = key.substring(7); } List<Object> arguments = new ArrayList<Object>(); for (Object arg : error.getArguments()) { if (!(arg instanceof org.springframework.context.support.DefaultMessageSourceResolvable)) { arguments.add(arg); } } if (!errors.containsKey(key)) { errors.put(key, new ArrayList<ValidationError>()); } errors .get(key) .add( new ValidationError( key, error.isBindingFailure() ? "error.invalid" : error.getDefaultMessage(), arguments)); } return new Form(rootName, backedType, data, errors, None(), groups); } else { Object globalError = null; if (result.getTarget() != null) { try { java.lang.reflect.Method v = result.getTarget().getClass().getMethod("validate"); globalError = v.invoke(result.getTarget()); } catch (NoSuchMethodException e) { } catch (Throwable e) { throw new RuntimeException(e); } } if (globalError != null) { Map<String, List<ValidationError>> errors = new HashMap<String, List<ValidationError>>(); if (globalError instanceof String) { errors.put("", new ArrayList<ValidationError>()); errors.get("").add(new ValidationError("", (String) globalError, new ArrayList())); } else if (globalError instanceof List) { errors.put("", (List<ValidationError>) globalError); } else if (globalError instanceof Map) { errors = (Map<String, List<ValidationError>>) globalError; } return new Form(rootName, backedType, data, errors, None(), groups); } return new Form( rootName, backedType, new HashMap<String, String>(data), new HashMap<String, List<ValidationError>>(errors), Some((T) result.getTarget()), groups); } }