wip data tables

mifosng-provider/src/main/java/org/mifosng/platform/api/infrastructure/ApiDataConversionServiceImpl.java

@@ -29,6 +29,7 @@ import org.mifosng.platform.api.commands.DepositStateTransitionApprovalCommand;
 import org.mifosng.platform.api.commands.DepositStateTransitionCommand;
 import org.mifosng.platform.api.commands.FundCommand;
 import org.mifosng.platform.api.commands.GroupCommand;
+import org.mifosng.platform.api.commands.LoanApplicationCommand;
 import org.mifosng.platform.api.commands.LoanChargeCommand;
 import org.mifosng.platform.api.commands.LoanProductCommand;
 import org.mifosng.platform.api.commands.LoanStateTransitionCommand;
@@ -39,13 +40,11 @@ import org.mifosng.platform.api.commands.OrganisationCurrencyCommand;
 import org.mifosng.platform.api.commands.RoleCommand;
 import org.mifosng.platform.api.commands.SavingProductCommand;
 import org.mifosng.platform.api.commands.StaffCommand;
-import org.mifosng.platform.api.commands.LoanApplicationCommand;
 import org.mifosng.platform.api.commands.UserCommand;
 import org.mifosng.platform.api.data.ApiParameterError;
 import org.mifosng.platform.api.errorhandling.InvalidJsonException;
 import org.mifosng.platform.api.errorhandling.UnsupportedParameterException;
 import org.mifosng.platform.exceptions.PlatformApiDataValidationException;
-import org.springframework.context.i18n.LocaleContextHolder;
 import org.springframework.format.number.NumberFormatter;
 import org.springframework.stereotype.Service;
 
@@ -161,7 +160,7 @@ public class ApiDataConversionServiceImpl implements ApiDataConversionService {
 	    Map<String, String> requestMap = gsonConverter.fromJson(json, typeOfMap);
 	    
 	    Set<String> supportedParams = new HashSet<String>(
-	    		Arrays.asList("name", "externalId", "parentId", "openingDate", "dateFormat")
+	    		Arrays.asList("name", "externalId", "parentId", "openingDate", "locale", "dateFormat")
 	    );
 	    
 	    checkForUnsupportedParameters(requestMap, supportedParams);
@@ -312,7 +311,7 @@ public class ApiDataConversionServiceImpl implements ApiDataConversionService {
 	    Map<String, String> requestMap = gsonConverter.fromJson(json, typeOfMap);
 	    
 	    Set<String> supportedParams = new HashSet<String>(
-	    		Arrays.asList("externalId", "firstname", "lastname", "clientOrBusinessName", "officeId", "joiningDate", "dateFormat")
+	    		Arrays.asList("externalId", "firstname", "lastname", "clientOrBusinessName", "officeId", "joiningDate", "locale", "dateFormat")
 	    );
 	    
 	    checkForUnsupportedParameters(requestMap, supportedParams);
@@ -559,7 +558,7 @@ public class ApiDataConversionServiceImpl implements ApiDataConversionService {
 	    Map<String, Object> requestMap = gsonConverter.fromJson(json, typeOfMap);
 	    
 	    Set<String> supportedParams = new HashSet<String>(
-	    		Arrays.asList("eventDate", "note", "dateFormat")
+	    		Arrays.asList("eventDate", "note", "locale", "dateFormat")
 	    );
 	    
 	    checkForUnsupportedParameters(requestMap, supportedParams);
@@ -763,7 +762,8 @@ public class ApiDataConversionServiceImpl implements ApiDataConversionService {
 			String valueAsString = (String) requestMap.get(paramName);
 			if (StringUtils.isNotBlank(valueAsString)) {
 				final String dateFormat = (String) requestMap.get("dateFormat");
-				paramValue = convertFrom(valueAsString, paramName, dateFormat);
+				final Locale locale = new Locale((String) requestMap.get("locale"));
+				paramValue = convertFrom(valueAsString, paramName, dateFormat, locale);
 			}
 			modifiedParameters.add(paramName);
 		}
@@ -780,6 +780,222 @@ public class ApiDataConversionServiceImpl implements ApiDataConversionService {
 		return clientApplicationLocale;
 	}
 	
+
+	private LocalDate convertFrom(final String dateAsString,
+			final String parameterName, final String dateFormat,
+			final Locale clientApplicationLocale) {
+
+		if (StringUtils.isBlank(dateFormat) || clientApplicationLocale == null) {
+
+			List<ApiParameterError> dataValidationErrors = new ArrayList<ApiParameterError>();
+			if (StringUtils.isBlank(dateFormat)) {
+				String defaultMessage = new StringBuilder(
+						"The parameter '"
+								+ parameterName
+								+ "' requires a 'dateFormat' parameter to be passed with it.")
+						.toString();
+				ApiParameterError error = ApiParameterError.parameterError(
+						"validation.msg.missing.dateFormat.parameter",
+						defaultMessage, parameterName);
+				dataValidationErrors.add(error);
+			}
+			if (clientApplicationLocale == null) {
+				String defaultMessage = new StringBuilder(
+						"The parameter '"
+								+ parameterName
+								+ "' requires a 'locale' parameter to be passed with it.")
+						.toString();
+				ApiParameterError error = ApiParameterError.parameterError(
+						"validation.msg.missing.locale.parameter",
+						defaultMessage, parameterName);
+				dataValidationErrors.add(error);
+			}
+			throw new PlatformApiDataValidationException(
+					"validation.msg.validation.errors.exist",
+					"Validation errors exist.", dataValidationErrors);
+		}
+
+		LocalDate eventLocalDate = null;
+		if (StringUtils.isNotBlank(dateAsString)) {
+			try {
+				// Locale locale = LocaleContextHolder.getLocale();
+				eventLocalDate = DateTimeFormat
+						.forPattern(dateFormat)
+						.withLocale(clientApplicationLocale)
+						.parseLocalDate(
+								dateAsString
+										.toLowerCase(clientApplicationLocale));
+			} catch (IllegalArgumentException e) {
+				List<ApiParameterError> dataValidationErrors = new ArrayList<ApiParameterError>();
+				ApiParameterError error = ApiParameterError.parameterError(
+						"validation.msg.invalid.date.format", "The parameter "
+								+ parameterName
+								+ " is invalid based on the dateFormat: '"
+								+ dateFormat + "' and locale: '"
+								+ clientApplicationLocale + "' provided:",
+						parameterName, dateAsString, dateFormat);
+				dataValidationErrors.add(error);
+
+				throw new PlatformApiDataValidationException(
+						"validation.msg.validation.errors.exist",
+						"Validation errors exist.", dataValidationErrors);
+			}
+		}
+
+		return eventLocalDate;
+	}
+
+	private Integer convertToInteger(final String numericalValueFormatted,
+			final String parameterName, final Locale clientApplicationLocale) {
+
+		if (clientApplicationLocale == null) {
+
+			List<ApiParameterError> dataValidationErrors = new ArrayList<ApiParameterError>();
+			String defaultMessage = new StringBuilder("The parameter '"
+					+ parameterName
+					+ "' requires a 'locale' parameter to be passed with it.")
+					.toString();
+			ApiParameterError error = ApiParameterError.parameterError(
+					"validation.msg.missing.locale.parameter", defaultMessage,
+					parameterName);
+			dataValidationErrors.add(error);
+
+			throw new PlatformApiDataValidationException(
+					"validation.msg.validation.errors.exist",
+					"Validation errors exist.", dataValidationErrors);
+		}
+
+		try {
+			Integer number = null;
+
+			if (StringUtils.isNotBlank(numericalValueFormatted)) {
+
+				String source = numericalValueFormatted.trim();
+
+				NumberFormat format = NumberFormat
+						.getInstance(clientApplicationLocale);
+				DecimalFormat df = (DecimalFormat) format;
+				DecimalFormatSymbols symbols = df.getDecimalFormatSymbols();
+				df.setParseBigDecimal(true);
+
+				// http://bugs.sun.com/view_bug.do?bug_id=4510618
+				char groupingSeparator = symbols.getGroupingSeparator();
+				if (groupingSeparator == '\u00a0') {
+					source = source.replaceAll(" ",
+							Character.toString('\u00a0'));
+				}
+
+				Number parsedNumber = df.parse(source);
+
+				double parsedNumberDouble = parsedNumber.doubleValue();
+				int parsedNumberInteger = parsedNumber.intValue();
+
+				if (source.contains(Character.toString(symbols
+						.getDecimalSeparator()))) {
+					throw new ParseException(source, 0);
+				}
+
+				if (!Double.valueOf(parsedNumberDouble).equals(
+						Double.valueOf(Integer.valueOf(parsedNumberInteger)))) {
+					throw new ParseException(source, 0);
+				}
+
+				number = parsedNumber.intValue();
+			}
+
+			return number;
+		} catch (ParseException e) {
+
+			List<ApiParameterError> dataValidationErrors = new ArrayList<ApiParameterError>();
+			ApiParameterError error = ApiParameterError
+					.parameterError(
+							"validation.msg.invalid.integer.format",
+							"The parameter "
+									+ parameterName
+									+ " has value: "
+									+ numericalValueFormatted
+									+ " which is invalid integer value for provided locale of ["
+									+ clientApplicationLocale.toString() + "].",
+							parameterName, numericalValueFormatted,
+							clientApplicationLocale);
+			dataValidationErrors.add(error);
+
+			throw new PlatformApiDataValidationException(
+					"validation.msg.validation.errors.exist",
+					"Validation errors exist.", dataValidationErrors);
+		}
+	}
+
+	private BigDecimal convertFrom(final String numericalValueFormatted,
+			final String parameterName, final Locale clientApplicationLocale) {
+
+		if (clientApplicationLocale == null) {
+
+			List<ApiParameterError> dataValidationErrors = new ArrayList<ApiParameterError>();
+			String defaultMessage = new StringBuilder("The parameter '"
+					+ parameterName
+					+ "' requires a 'locale' parameter to be passed with it.")
+					.toString();
+			ApiParameterError error = ApiParameterError.parameterError(
+					"validation.msg.missing.locale.parameter", defaultMessage,
+					parameterName);
+			dataValidationErrors.add(error);
+
+			throw new PlatformApiDataValidationException(
+					"validation.msg.validation.errors.exist",
+					"Validation errors exist.", dataValidationErrors);
+		}
+
+		try {
+			BigDecimal number = null;
+
+			if (StringUtils.isNotBlank(numericalValueFormatted)) {
+
+				String source = numericalValueFormatted.trim();
+
+				NumberFormat format = NumberFormat
+						.getNumberInstance(clientApplicationLocale);
+				DecimalFormat df = (DecimalFormat) format;
+				DecimalFormatSymbols symbols = df.getDecimalFormatSymbols();
+				// http://bugs.sun.com/view_bug.do?bug_id=4510618
+				char groupingSeparator = symbols.getGroupingSeparator();
+				if (groupingSeparator == '\u00a0') {
+					source = source.replaceAll(" ",
+							Character.toString('\u00a0'));
+				}
+
+				NumberFormatter numberFormatter = new NumberFormatter();
+				Number parsedNumber = numberFormatter.parse(source,
+						clientApplicationLocale);
+				number = BigDecimal.valueOf(Double.valueOf(parsedNumber
+						.doubleValue()));
+			}
+
+			return number;
+		} catch (ParseException e) {
+
+			List<ApiParameterError> dataValidationErrors = new ArrayList<ApiParameterError>();
+			ApiParameterError error = ApiParameterError
+					.parameterError(
+							"validation.msg.invalid.decimal.format",
+							"The parameter "
+									+ parameterName
+									+ " has value: "
+									+ numericalValueFormatted
+									+ " which is invalid decimal value for provided locale of ["
+									+ clientApplicationLocale.toString() + "].",
+							parameterName, numericalValueFormatted,
+							clientApplicationLocale);
+			dataValidationErrors.add(error);
+
+			throw new PlatformApiDataValidationException(
+					"validation.msg.validation.errors.exist",
+					"Validation errors exist.", dataValidationErrors);
+		}
+	}
+
+
+	/*
 	private LocalDate convertFrom(final String dateAsString, final String parameterName, final String dateFormat) {
 		
 		if (StringUtils.isBlank(dateFormat)) {
@@ -940,7 +1156,7 @@ public class ApiDataConversionServiceImpl implements ApiDataConversionService {
 					"Validation errors exist.", dataValidationErrors);
 		}
 	}
-
+*/
 	private Locale localeFromString(final String localeAsString) {
 		
 		if (StringUtils.isBlank(localeAsString)) {
@@ -1130,7 +1346,7 @@ public class ApiDataConversionServiceImpl implements ApiDataConversionService {
 		Type typeOfMap = new TypeToken<Map<String, Object>>(){}.getType();
 	    Map<String, Object> requestMap = gsonConverter.fromJson(json, typeOfMap);
 	    
-	    Set<String> supportedParams = new HashSet<String>( Arrays.asList("eventDate", "dateFormat", "note"));
+	    Set<String> supportedParams = new HashSet<String>( Arrays.asList("eventDate", "locale", "dateFormat", "note"));
 	    
 	    checkForUnsupportedParameters(requestMap, supportedParams);
 	    
@@ -1153,7 +1369,7 @@ public class ApiDataConversionServiceImpl implements ApiDataConversionService {
 		Type typeOfMap = new TypeToken<Map<String, String>>(){}.getType();
 	    Map<String, String> requestMap = gsonConverter.fromJson(json, typeOfMap);
 	    
-	    Set<String> supportedParams = new HashSet<String>(Arrays.asList("locale","commencementDate", "dateFormat", "tenureInMonths", "deposit", "interestCompoundedEveryPeriodType", "productId","interestCompoundedEvery","note"));
+	    Set<String> supportedParams = new HashSet<String>(Arrays.asList("locale","commencementDate", "locale", "dateFormat", "tenureInMonths", "deposit", "interestCompoundedEveryPeriodType", "productId","interestCompoundedEvery","note"));
 	    
 	    checkForUnsupportedParameters(requestMap, supportedParams);
 	    

mifosng-provider/src/main/java/org/mifosng/platform/api/infrastructure/JsonParserHelper.java

@@ -16,7 +16,6 @@ import org.joda.time.LocalDate;
 import org.joda.time.format.DateTimeFormat;
 import org.mifosng.platform.api.data.ApiParameterError;
 import org.mifosng.platform.exceptions.PlatformApiDataValidationException;
-import org.springframework.context.i18n.LocaleContextHolder;
 import org.springframework.format.number.NumberFormatter;
 
 import com.google.gson.JsonElement;
@@ -28,13 +27,16 @@ import com.google.gson.JsonPrimitive;
  */
 public class JsonParserHelper {
 
-	public Long extractLongNamed(final String parameterName, final JsonElement element, final Set<String> modifiedParameters) {
+	public Long extractLongNamed(final String parameterName,
+			final JsonElement element, final Set<String> modifiedParameters) {
 		Long longValue = null;
 		if (element.isJsonObject()) {
 			JsonObject object = element.getAsJsonObject();
-			if (object.has(parameterName) && object.get(parameterName).isJsonPrimitive()) {
+			if (object.has(parameterName)
+					&& object.get(parameterName).isJsonPrimitive()) {
 				modifiedParameters.add(parameterName);
-				JsonPrimitive primitive = object.get(parameterName).getAsJsonPrimitive();
+				JsonPrimitive primitive = object.get(parameterName)
+						.getAsJsonPrimitive();
 				final String stringValue = primitive.getAsString();
 				if (StringUtils.isNotBlank(stringValue)) {
 					longValue = Long.valueOf(stringValue);
@@ -44,13 +46,16 @@ public class JsonParserHelper {
 		return longValue;
 	}
 
-	public String extractStringNamed(final String parameterName, final JsonElement element, final Set<String> modifiedParameters) {
+	public String extractStringNamed(final String parameterName,
+			final JsonElement element, final Set<String> modifiedParameters) {
 		String stringValue = null;
 		if (element.isJsonObject()) {
 			JsonObject object = element.getAsJsonObject();
-			if (object.has(parameterName) && object.get(parameterName).isJsonPrimitive()) {
+			if (object.has(parameterName)
+					&& object.get(parameterName).isJsonPrimitive()) {
 				modifiedParameters.add(parameterName);
-				JsonPrimitive primitive = object.get(parameterName).getAsJsonPrimitive();
+				JsonPrimitive primitive = object.get(parameterName)
+						.getAsJsonPrimitive();
 				if (StringUtils.isNotBlank(stringValue)) {
 					stringValue = primitive.getAsString();
 				}
@@ -59,94 +64,140 @@ public class JsonParserHelper {
 		return stringValue;
 	}
 
-	public BigDecimal extractBigDecimalNamed(final String parameterName, final JsonElement element, final Set<String> modifiedParameters) {
+	public BigDecimal extractBigDecimalNamed(final String parameterName,
+			final JsonElement element, final Set<String> modifiedParameters) {
 		BigDecimal value = null;
 		if (element.isJsonObject()) {
 			JsonObject object = element.getAsJsonObject();
-			if (object.has(parameterName) && object.get(parameterName).isJsonPrimitive()) {
+			if (object.has(parameterName)
+					&& object.get(parameterName).isJsonPrimitive()) {
 				modifiedParameters.add(parameterName);
-				JsonPrimitive primitive = object.get(parameterName).getAsJsonPrimitive();
+				JsonPrimitive primitive = object.get(parameterName)
+						.getAsJsonPrimitive();
 				String valueAsString = primitive.getAsString();
 				if (StringUtils.isNotBlank(valueAsString)) {
-					value = convertFrom(valueAsString, parameterName, extractLocaleValue(object));
+					value = convertFrom(valueAsString, parameterName,
-				}
+							extractLocaleValue(object));
-			}
-		}
-		return value;
-	}
-	
-	public Integer extractIntegerNamed(final String parameterName, final JsonElement element, final Set<String> modifiedParameters) {
-		Integer value = null;
-		if (element.isJsonObject()) {
-			JsonObject object = element.getAsJsonObject();
-			if (object.has(parameterName) && object.get(parameterName).isJsonPrimitive()) {
-				modifiedParameters.add(parameterName);
-				JsonPrimitive primitive = object.get(parameterName).getAsJsonPrimitive();
-				String valueAsString = primitive.getAsString();
-				if (StringUtils.isNotBlank(valueAsString)) {
-					value = convertToInteger(valueAsString, parameterName, extractLocaleValue(object));
 				}
 			}
 		}
 		return value;
 	}
 
-	public LocalDate extractLocalDateNamed(final String parameterName, final JsonElement element, final Set<String> modifiedParameters) {
+	public Integer extractIntegerNamed(final String parameterName,
+			final JsonElement element, final Set<String> modifiedParameters) {
+		Integer value = null;
+		if (element.isJsonObject()) {
+			JsonObject object = element.getAsJsonObject();
+			if (object.has(parameterName)
+					&& object.get(parameterName).isJsonPrimitive()) {
+				modifiedParameters.add(parameterName);
+				JsonPrimitive primitive = object.get(parameterName)
+						.getAsJsonPrimitive();
+				String valueAsString = primitive.getAsString();
+				if (StringUtils.isNotBlank(valueAsString)) {
+					value = convertToInteger(valueAsString, parameterName,
+							extractLocaleValue(object));
+				}
+			}
+		}
+		return value;
+	}
+
+	public LocalDate extractLocalDateNamed(final String parameterName,
+			final JsonElement element, final Set<String> modifiedParameters) {
 		LocalDate value = null;
 		if (element.isJsonObject()) {
 			JsonObject object = element.getAsJsonObject();
 
 			String dateFormat = null;
 			final String dateFormatParameter = "dateFormat";
-			if (object.has(dateFormatParameter) && object.get(dateFormatParameter).isJsonPrimitive()) {
+			if (object.has(dateFormatParameter)
-				JsonPrimitive primitive = object.get(dateFormatParameter).getAsJsonPrimitive();
+					&& object.get(dateFormatParameter).isJsonPrimitive()) {
+				JsonPrimitive primitive = object.get(dateFormatParameter)
+						.getAsJsonPrimitive();
 				dateFormat = primitive.getAsString();
 			}
-			
+			String locale = null;
-			if (object.has(parameterName) && object.get(parameterName).isJsonPrimitive()) {
+			Locale clientApplicationLocale = null;
+			final String localeParameter = "locale";
+			if (object.has(localeParameter)
+					&& object.get(localeParameter).isJsonPrimitive()) {
+				JsonPrimitive primitive = object.get(localeParameter)
+						.getAsJsonPrimitive();
+				locale = primitive.getAsString();
+				clientApplicationLocale = localeFromString(locale);
+			}
+
+			if (object.has(parameterName)
+					&& object.get(parameterName).isJsonPrimitive()) {
 				modifiedParameters.add(parameterName);
-				JsonPrimitive primitive = object.get(parameterName).getAsJsonPrimitive();
+				JsonPrimitive primitive = object.get(parameterName)
+						.getAsJsonPrimitive();
 				final String valueAsString = primitive.getAsString();
 				if (StringUtils.isNotBlank(valueAsString)) {
-					value = convertFrom(valueAsString, parameterName, dateFormat);
+					value = convertFrom(valueAsString, parameterName,
+							dateFormat, clientApplicationLocale);
 				}
 			}
-			
+
 		}
 		return value;
 	}
-	
+
-	private LocalDate convertFrom(final String dateAsString, final String parameterName, final String dateFormat) {
+	public LocalDate convertFrom(final String dateAsString,
-		
+			final String parameterName, final String dateFormat,
-		if (StringUtils.isBlank(dateFormat)) {
+			final Locale clientApplicationLocale) {
-			
+
+		if (StringUtils.isBlank(dateFormat) || clientApplicationLocale == null) {
+
 			List<ApiParameterError> dataValidationErrors = new ArrayList<ApiParameterError>();
-			String defaultMessage = new StringBuilder("The parameter '" + parameterName + "' requires a 'dateFormat' parameter to be passed with it.").toString();
+			if (StringUtils.isBlank(dateFormat)) {
-			ApiParameterError error = ApiParameterError.parameterError("validation.msg.missing.dateFormat.parameter", defaultMessage, parameterName);
+				String defaultMessage = new StringBuilder(
-			dataValidationErrors.add(error);
+						"The parameter '"
-			
+								+ parameterName
+								+ "' requires a 'dateFormat' parameter to be passed with it.")
+						.toString();
+				ApiParameterError error = ApiParameterError.parameterError(
+						"validation.msg.missing.dateFormat.parameter",
+						defaultMessage, parameterName);
+				dataValidationErrors.add(error);
+			}
+			if (clientApplicationLocale == null) {
+				String defaultMessage = new StringBuilder(
+						"The parameter '"
+								+ parameterName
+								+ "' requires a 'locale' parameter to be passed with it.")
+						.toString();
+				ApiParameterError error = ApiParameterError.parameterError(
+						"validation.msg.missing.locale.parameter",
+						defaultMessage, parameterName);
+				dataValidationErrors.add(error);
+			}
 			throw new PlatformApiDataValidationException(
 					"validation.msg.validation.errors.exist",
 					"Validation errors exist.", dataValidationErrors);
 		}
-		
+
 		LocalDate eventLocalDate = null;
 		if (StringUtils.isNotBlank(dateAsString)) {
 			try {
-				Locale locale = LocaleContextHolder.getLocale();
+				// Locale locale = LocaleContextHolder.getLocale();
-				eventLocalDate = DateTimeFormat.forPattern(dateFormat)
+				eventLocalDate = DateTimeFormat
-						.withLocale(locale)
+						.forPattern(dateFormat)
-						.parseLocalDate(dateAsString.toLowerCase(locale));
+						.withLocale(clientApplicationLocale)
+						.parseLocalDate(
+								dateAsString
+										.toLowerCase(clientApplicationLocale));
 			} catch (IllegalArgumentException e) {
 				List<ApiParameterError> dataValidationErrors = new ArrayList<ApiParameterError>();
-				ApiParameterError error = ApiParameterError
+				ApiParameterError error = ApiParameterError.parameterError(
-						.parameterError(
+						"validation.msg.invalid.date.format", "The parameter "
-								"validation.msg.invalid.date.format",
+								+ parameterName
-								"The parameter "
+								+ " is invalid based on the dateFormat: '"
-										+ parameterName
+								+ dateFormat + "' and locale: '"
-										+ " is invalid based on the dateFormat provided:"
+								+ clientApplicationLocale + "' provided:",
-										+ dateFormat, parameterName,
+						parameterName, dateAsString, dateFormat);
-								dateAsString, dateFormat);
 				dataValidationErrors.add(error);
 
 				throw new PlatformApiDataValidationException(
@@ -157,105 +208,62 @@ public class JsonParserHelper {
 
 		return eventLocalDate;
 	}
-	
+
-	private BigDecimal convertFrom(final String numericalValueFormatted, final String parameterName, final Locale clientApplicationLocale) {
+	public Integer convertToInteger(final String numericalValueFormatted,
+			final String parameterName, final Locale clientApplicationLocale) {
 
 		if (clientApplicationLocale == null) {
-			
-			List<ApiParameterError> dataValidationErrors = new ArrayList<ApiParameterError>();
-			String defaultMessage = new StringBuilder("The parameter '" + parameterName + "' requires a 'locale' parameter to be passed with it.").toString();
-			ApiParameterError error = ApiParameterError.parameterError("validation.msg.missing.locale.parameter", defaultMessage, parameterName);
-			dataValidationErrors.add(error);
-			
-			throw new PlatformApiDataValidationException(
-					"validation.msg.validation.errors.exist",
-					"Validation errors exist.", dataValidationErrors);
-		}
-		
-		try {
-			BigDecimal number = null;
-			
-			if (StringUtils.isNotBlank(numericalValueFormatted)) {
-				
-				String source = numericalValueFormatted.trim();
-				
-				NumberFormat format = NumberFormat.getNumberInstance(clientApplicationLocale);
-				DecimalFormat df = (DecimalFormat) format;
-				DecimalFormatSymbols symbols = df.getDecimalFormatSymbols();
-				// http://bugs.sun.com/view_bug.do?bug_id=4510618
-				char groupingSeparator = symbols.getGroupingSeparator();
-				if (groupingSeparator == '\u00a0') {
-					source = source.replaceAll(" ", Character.toString('\u00a0'));
-			    }
-				
-				NumberFormatter numberFormatter = new NumberFormatter();
-				Number parsedNumber = numberFormatter.parse(source, clientApplicationLocale);
-				number = BigDecimal.valueOf(Double.valueOf(parsedNumber.doubleValue()));
-			}
-
-			return number;
-		} catch (ParseException e) {
 
 			List<ApiParameterError> dataValidationErrors = new ArrayList<ApiParameterError>();
+			String defaultMessage = new StringBuilder("The parameter '"
+					+ parameterName
+					+ "' requires a 'locale' parameter to be passed with it.")
+					.toString();
 			ApiParameterError error = ApiParameterError.parameterError(
-					"validation.msg.invalid.decimal.format", "The parameter "
+					"validation.msg.missing.locale.parameter", defaultMessage,
-							+ parameterName + " has value: " + numericalValueFormatted + " which is invalid decimal value for provided locale of ["
+					parameterName);
-							+ clientApplicationLocale.toString() + "].",
-					parameterName, numericalValueFormatted,
-					clientApplicationLocale);
 			dataValidationErrors.add(error);
 
 			throw new PlatformApiDataValidationException(
 					"validation.msg.validation.errors.exist",
 					"Validation errors exist.", dataValidationErrors);
 		}
-	}
+
-	
-private Integer convertToInteger(final String numericalValueFormatted, final String parameterName, final Locale clientApplicationLocale) {
-		
-		if (clientApplicationLocale == null) {
-			
-			List<ApiParameterError> dataValidationErrors = new ArrayList<ApiParameterError>();
-			String defaultMessage = new StringBuilder("The parameter '" + parameterName + "' requires a 'locale' parameter to be passed with it.").toString();
-			ApiParameterError error = ApiParameterError.parameterError("validation.msg.missing.locale.parameter", defaultMessage, parameterName);
-			dataValidationErrors.add(error);
-			
-			throw new PlatformApiDataValidationException(
-					"validation.msg.validation.errors.exist",
-					"Validation errors exist.", dataValidationErrors);
-		}
-		
 		try {
 			Integer number = null;
 
 			if (StringUtils.isNotBlank(numericalValueFormatted)) {
-				
+
 				String source = numericalValueFormatted.trim();
-				
+
-				NumberFormat format = NumberFormat.getInstance(clientApplicationLocale);
+				NumberFormat format = NumberFormat
+						.getInstance(clientApplicationLocale);
 				DecimalFormat df = (DecimalFormat) format;
 				DecimalFormatSymbols symbols = df.getDecimalFormatSymbols();
 				df.setParseBigDecimal(true);
-				
+
 				// http://bugs.sun.com/view_bug.do?bug_id=4510618
 				char groupingSeparator = symbols.getGroupingSeparator();
 				if (groupingSeparator == '\u00a0') {
-					source = source.replaceAll(" ", Character.toString('\u00a0'));
+					source = source.replaceAll(" ",
-			    }
+							Character.toString('\u00a0'));
-				
+				}
+
 				Number parsedNumber = df.parse(source);
-				
+
 				double parsedNumberDouble = parsedNumber.doubleValue();
 				int parsedNumberInteger = parsedNumber.intValue();
-				
+
-				if (source.contains(Character.toString(symbols.getDecimalSeparator()))) {
+				if (source.contains(Character.toString(symbols
+						.getDecimalSeparator()))) {
 					throw new ParseException(source, 0);
 				}
-				
+
-				if (!Double.valueOf(parsedNumberDouble).equals(Double.valueOf(Integer.valueOf(parsedNumberInteger)))) {
+				if (!Double.valueOf(parsedNumberDouble).equals(
+						Double.valueOf(Integer.valueOf(parsedNumberInteger)))) {
 					throw new ParseException(source, 0);
 				}
-				
+
 				number = parsedNumber.intValue();
 			}
 
@@ -263,12 +271,17 @@ private Integer convertToInteger(final String numericalValueFormatted, final Str
 		} catch (ParseException e) {
 
 			List<ApiParameterError> dataValidationErrors = new ArrayList<ApiParameterError>();
-			ApiParameterError error = ApiParameterError.parameterError(
+			ApiParameterError error = ApiParameterError
-					"validation.msg.invalid.integer.format", "The parameter "
+					.parameterError(
-							+ parameterName + " has value: " + numericalValueFormatted + " which is invalid integer value for provided locale of ["
+							"validation.msg.invalid.integer.format",
-							+ clientApplicationLocale.toString() + "].",
+							"The parameter "
-					parameterName, numericalValueFormatted,
+									+ parameterName
-					clientApplicationLocale);
+									+ " has value: "
+									+ numericalValueFormatted
+									+ " which is invalid integer value for provided locale of ["
+									+ clientApplicationLocale.toString() + "].",
+							parameterName, numericalValueFormatted,
+							clientApplicationLocale);
 			dataValidationErrors.add(error);
 
 			throw new PlatformApiDataValidationException(
@@ -277,72 +290,302 @@ private Integer convertToInteger(final String numericalValueFormatted, final Str
 		}
 	}
 
-	private Locale localeFromString(final String localeAsString) {
+	public BigDecimal convertFrom(final String numericalValueFormatted,
-		
+			final String parameterName, final Locale clientApplicationLocale) {
-		if (StringUtils.isBlank(localeAsString)) {
+
+		if (clientApplicationLocale == null) {
+
 			List<ApiParameterError> dataValidationErrors = new ArrayList<ApiParameterError>();
-			ApiParameterError error = ApiParameterError.parameterError("validation.msg.invalid.locale.format", "The parameter locale is invalid. It cannot be blank.", "locale");
+			String defaultMessage = new StringBuilder("The parameter '"
+					+ parameterName
+					+ "' requires a 'locale' parameter to be passed with it.")
+					.toString();
+			ApiParameterError error = ApiParameterError.parameterError(
+					"validation.msg.missing.locale.parameter", defaultMessage,
+					parameterName);
 			dataValidationErrors.add(error);
 
 			throw new PlatformApiDataValidationException(
 					"validation.msg.validation.errors.exist",
 					"Validation errors exist.", dataValidationErrors);
 		}
-		
+
+		try {
+			BigDecimal number = null;
+
+			if (StringUtils.isNotBlank(numericalValueFormatted)) {
+
+				String source = numericalValueFormatted.trim();
+
+				NumberFormat format = NumberFormat
+						.getNumberInstance(clientApplicationLocale);
+				DecimalFormat df = (DecimalFormat) format;
+				DecimalFormatSymbols symbols = df.getDecimalFormatSymbols();
+				// http://bugs.sun.com/view_bug.do?bug_id=4510618
+				char groupingSeparator = symbols.getGroupingSeparator();
+				if (groupingSeparator == '\u00a0') {
+					source = source.replaceAll(" ",
+							Character.toString('\u00a0'));
+				}
+
+				NumberFormatter numberFormatter = new NumberFormatter();
+				Number parsedNumber = numberFormatter.parse(source,
+						clientApplicationLocale);
+				number = BigDecimal.valueOf(Double.valueOf(parsedNumber
+						.doubleValue()));
+			}
+
+			return number;
+		} catch (ParseException e) {
+
+			List<ApiParameterError> dataValidationErrors = new ArrayList<ApiParameterError>();
+			ApiParameterError error = ApiParameterError
+					.parameterError(
+							"validation.msg.invalid.decimal.format",
+							"The parameter "
+									+ parameterName
+									+ " has value: "
+									+ numericalValueFormatted
+									+ " which is invalid decimal value for provided locale of ["
+									+ clientApplicationLocale.toString() + "].",
+							parameterName, numericalValueFormatted,
+							clientApplicationLocale);
+			dataValidationErrors.add(error);
+
+			throw new PlatformApiDataValidationException(
+					"validation.msg.validation.errors.exist",
+					"Validation errors exist.", dataValidationErrors);
+		}
+	}
+
+	/*
+	 * private LocalDate convertFrom(final String dateAsString, final String
+	 * parameterName, final String dateFormat) {
+	 * 
+	 * if (StringUtils.isBlank(dateFormat)) {
+	 * 
+	 * List<ApiParameterError> dataValidationErrors = new
+	 * ArrayList<ApiParameterError>(); String defaultMessage = new
+	 * StringBuilder("The parameter '" + parameterName +
+	 * "' requires a 'dateFormat' parameter to be passed with it.").toString();
+	 * ApiParameterError error = ApiParameterError.parameterError(
+	 * "validation.msg.missing.dateFormat.parameter", defaultMessage,
+	 * parameterName); dataValidationErrors.add(error);
+	 * 
+	 * throw new PlatformApiDataValidationException(
+	 * "validation.msg.validation.errors.exist", "Validation errors exist.",
+	 * dataValidationErrors); }
+	 * 
+	 * LocalDate eventLocalDate = null; if
+	 * (StringUtils.isNotBlank(dateAsString)) { try { Locale locale =
+	 * LocaleContextHolder.getLocale(); eventLocalDate =
+	 * DateTimeFormat.forPattern(dateFormat) .withLocale(locale)
+	 * .parseLocalDate(dateAsString.toLowerCase(locale)); } catch
+	 * (IllegalArgumentException e) { List<ApiParameterError>
+	 * dataValidationErrors = new ArrayList<ApiParameterError>();
+	 * ApiParameterError error = ApiParameterError .parameterError(
+	 * "validation.msg.invalid.date.format", "The parameter " + parameterName +
+	 * " is invalid based on the dateFormat provided:" + dateFormat,
+	 * parameterName, dateAsString, dateFormat);
+	 * dataValidationErrors.add(error);
+	 * 
+	 * throw new PlatformApiDataValidationException(
+	 * "validation.msg.validation.errors.exist", "Validation errors exist.",
+	 * dataValidationErrors); } }
+	 * 
+	 * return eventLocalDate; }
+	 * 
+	 * private BigDecimal convertFrom(final String numericalValueFormatted,
+	 * final String parameterName, final Locale clientApplicationLocale) {
+	 * 
+	 * if (clientApplicationLocale == null) {
+	 * 
+	 * List<ApiParameterError> dataValidationErrors = new
+	 * ArrayList<ApiParameterError>(); String defaultMessage = new
+	 * StringBuilder("The parameter '" + parameterName +
+	 * "' requires a 'locale' parameter to be passed with it.").toString();
+	 * ApiParameterError error =
+	 * ApiParameterError.parameterError("validation.msg.missing.locale.parameter"
+	 * , defaultMessage, parameterName); dataValidationErrors.add(error);
+	 * 
+	 * throw new PlatformApiDataValidationException(
+	 * "validation.msg.validation.errors.exist", "Validation errors exist.",
+	 * dataValidationErrors); }
+	 * 
+	 * try { BigDecimal number = null;
+	 * 
+	 * if (StringUtils.isNotBlank(numericalValueFormatted)) {
+	 * 
+	 * String source = numericalValueFormatted.trim();
+	 * 
+	 * NumberFormat format =
+	 * NumberFormat.getNumberInstance(clientApplicationLocale); DecimalFormat df
+	 * = (DecimalFormat) format; DecimalFormatSymbols symbols =
+	 * df.getDecimalFormatSymbols(); //
+	 * http://bugs.sun.com/view_bug.do?bug_id=4510618 char groupingSeparator =
+	 * symbols.getGroupingSeparator(); if (groupingSeparator == '\u00a0') {
+	 * source = source.replaceAll(" ", Character.toString('\u00a0')); }
+	 * 
+	 * NumberFormatter numberFormatter = new NumberFormatter(); Number
+	 * parsedNumber = numberFormatter.parse(source, clientApplicationLocale);
+	 * number = BigDecimal.valueOf(Double.valueOf(parsedNumber.doubleValue()));
+	 * }
+	 * 
+	 * return number; } catch (ParseException e) {
+	 * 
+	 * List<ApiParameterError> dataValidationErrors = new
+	 * ArrayList<ApiParameterError>(); ApiParameterError error =
+	 * ApiParameterError.parameterError(
+	 * "validation.msg.invalid.decimal.format", "The parameter " + parameterName
+	 * + " has value: " + numericalValueFormatted +
+	 * " which is invalid decimal value for provided locale of [" +
+	 * clientApplicationLocale.toString() + "].", parameterName,
+	 * numericalValueFormatted, clientApplicationLocale);
+	 * dataValidationErrors.add(error);
+	 * 
+	 * throw new PlatformApiDataValidationException(
+	 * "validation.msg.validation.errors.exist", "Validation errors exist.",
+	 * dataValidationErrors); } }
+	 * 
+	 * private Integer convertToInteger(final String numericalValueFormatted,
+	 * final String parameterName, final Locale clientApplicationLocale) {
+	 * 
+	 * if (clientApplicationLocale == null) {
+	 * 
+	 * List<ApiParameterError> dataValidationErrors = new
+	 * ArrayList<ApiParameterError>(); String defaultMessage = new
+	 * StringBuilder("The parameter '" + parameterName +
+	 * "' requires a 'locale' parameter to be passed with it.").toString();
+	 * ApiParameterError error =
+	 * ApiParameterError.parameterError("validation.msg.missing.locale.parameter"
+	 * , defaultMessage, parameterName); dataValidationErrors.add(error);
+	 * 
+	 * throw new PlatformApiDataValidationException(
+	 * "validation.msg.validation.errors.exist", "Validation errors exist.",
+	 * dataValidationErrors); }
+	 * 
+	 * try { Integer number = null;
+	 * 
+	 * if (StringUtils.isNotBlank(numericalValueFormatted)) {
+	 * 
+	 * String source = numericalValueFormatted.trim();
+	 * 
+	 * NumberFormat format = NumberFormat.getInstance(clientApplicationLocale);
+	 * DecimalFormat df = (DecimalFormat) format; DecimalFormatSymbols symbols =
+	 * df.getDecimalFormatSymbols(); df.setParseBigDecimal(true);
+	 * 
+	 * // http://bugs.sun.com/view_bug.do?bug_id=4510618 char groupingSeparator
+	 * = symbols.getGroupingSeparator(); if (groupingSeparator == '\u00a0') {
+	 * source = source.replaceAll(" ", Character.toString('\u00a0')); }
+	 * 
+	 * Number parsedNumber = df.parse(source);
+	 * 
+	 * double parsedNumberDouble = parsedNumber.doubleValue(); int
+	 * parsedNumberInteger = parsedNumber.intValue();
+	 * 
+	 * if (source.contains(Character.toString(symbols.getDecimalSeparator()))) {
+	 * throw new ParseException(source, 0); }
+	 * 
+	 * if
+	 * (!Double.valueOf(parsedNumberDouble).equals(Double.valueOf(Integer.valueOf
+	 * (parsedNumberInteger)))) { throw new ParseException(source, 0); }
+	 * 
+	 * number = parsedNumber.intValue(); }
+	 * 
+	 * return number; } catch (ParseException e) {
+	 * 
+	 * List<ApiParameterError> dataValidationErrors = new
+	 * ArrayList<ApiParameterError>(); ApiParameterError error =
+	 * ApiParameterError.parameterError(
+	 * "validation.msg.invalid.integer.format", "The parameter " + parameterName
+	 * + " has value: " + numericalValueFormatted +
+	 * " which is invalid integer value for provided locale of [" +
+	 * clientApplicationLocale.toString() + "].", parameterName,
+	 * numericalValueFormatted, clientApplicationLocale);
+	 * dataValidationErrors.add(error);
+	 * 
+	 * throw new PlatformApiDataValidationException(
+	 * "validation.msg.validation.errors.exist", "Validation errors exist.",
+	 * dataValidationErrors); } }
+	 */
+	private Locale localeFromString(final String localeAsString) {
+
+		if (StringUtils.isBlank(localeAsString)) {
+			List<ApiParameterError> dataValidationErrors = new ArrayList<ApiParameterError>();
+			ApiParameterError error = ApiParameterError.parameterError(
+					"validation.msg.invalid.locale.format",
+					"The parameter locale is invalid. It cannot be blank.",
+					"locale");
+			dataValidationErrors.add(error);
+
+			throw new PlatformApiDataValidationException(
+					"validation.msg.validation.errors.exist",
+					"Validation errors exist.", dataValidationErrors);
+		}
+
 		String languageCode = "";
 		String courntryCode = "";
 		String variantCode = "";
-		
+
 		String[] localeParts = localeAsString.split("_");
-		
+
 		if (localeParts != null && localeParts.length == 1) {
 			languageCode = localeParts[0];
 		}
-		
+
 		if (localeParts != null && localeParts.length == 2) {
 			languageCode = localeParts[0];
 			courntryCode = localeParts[1];
 		}
-		
+
 		if (localeParts != null && localeParts.length == 3) {
 			languageCode = localeParts[0];
 			courntryCode = localeParts[1];
 			variantCode = localeParts[2];
 		}
-		
+
 		return localeFrom(languageCode, courntryCode, variantCode);
 	}
 
-	private Locale localeFrom(final String languageCode, final String courntryCode, final String variantCode) {
+	private Locale localeFrom(final String languageCode,
-		
+			final String courntryCode, final String variantCode) {
+
 		List<ApiParameterError> dataValidationErrors = new ArrayList<ApiParameterError>();
-		
+
 		List<String> allowedLanguages = Arrays.asList(Locale.getISOLanguages());
 		if (!allowedLanguages.contains(languageCode.toLowerCase())) {
-			ApiParameterError error = ApiParameterError.parameterError("validation.msg.invalid.locale.format", "The parameter locale has an invalid language value " + languageCode + " .", "locale", languageCode);
+			ApiParameterError error = ApiParameterError.parameterError(
-			dataValidationErrors.add(error);			
+					"validation.msg.invalid.locale.format",
+					"The parameter locale has an invalid language value "
+							+ languageCode + " .", "locale", languageCode);
+			dataValidationErrors.add(error);
 		}
-		
+
 		if (StringUtils.isNotBlank(courntryCode.toUpperCase())) {
-			List<String> allowedCountries = Arrays.asList(Locale.getISOCountries());
+			List<String> allowedCountries = Arrays.asList(Locale
+					.getISOCountries());
 			if (!allowedCountries.contains(courntryCode)) {
-				ApiParameterError error = ApiParameterError.parameterError("validation.msg.invalid.locale.format", "The parameter locale has an invalid country value " + courntryCode + " .", "locale", courntryCode);
+				ApiParameterError error = ApiParameterError.parameterError(
-				dataValidationErrors.add(error);			
+						"validation.msg.invalid.locale.format",
+						"The parameter locale has an invalid country value "
+								+ courntryCode + " .", "locale", courntryCode);
+				dataValidationErrors.add(error);
 			}
 		}
-		
+
 		if (!dataValidationErrors.isEmpty()) {
 			throw new PlatformApiDataValidationException(
 					"validation.msg.validation.errors.exist",
 					"Validation errors exist.", dataValidationErrors);
 		}
-		
+
-		return new Locale(languageCode.toLowerCase(), courntryCode.toUpperCase(), variantCode);
+		return new Locale(languageCode.toLowerCase(),
+				courntryCode.toUpperCase(), variantCode);
 	}
-	
+
 	private Locale extractLocaleValue(final JsonObject object) {
 		Locale clientApplicationLocale = null;
-	    String locale = null;
+		String locale = null;
 		if (object.has("locale") && object.get("locale").isJsonPrimitive()) {
 			JsonPrimitive primitive = object.get("locale").getAsJsonPrimitive();
 			locale = primitive.getAsString();

mifosng-provider/src/main/java/org/mifosng/platform/noncore/ReadWriteNonCoreDataServiceImpl.java

@@ -1,12 +1,7 @@
 package org.mifosng.platform.noncore;
 
-import java.math.BigDecimal;
 import java.sql.ResultSetMetaData;
 import java.sql.SQLException;
-import java.text.DecimalFormat;
-import java.text.DecimalFormatSymbols;
-import java.text.NumberFormat;
-import java.text.ParseException;
 import java.util.ArrayList;
 import java.util.HashMap;
 import java.util.List;
@@ -17,14 +12,13 @@ import java.util.Set;
 import javax.sql.rowset.CachedRowSet;
 
 import org.apache.commons.lang.StringUtils;
-import org.joda.time.LocalDate;
-import org.joda.time.format.DateTimeFormat;
 import org.mifosng.platform.api.data.ApiParameterError;
 import org.mifosng.platform.api.data.DatatableData;
 import org.mifosng.platform.api.data.GenericResultsetData;
 import org.mifosng.platform.api.data.ResultsetColumnHeader;
 import org.mifosng.platform.api.data.ResultsetColumnValue;
 import org.mifosng.platform.api.data.ResultsetDataRow;
+import org.mifosng.platform.api.infrastructure.JsonParserHelper;
 import org.mifosng.platform.exceptions.DataTableNotFoundException;
 import org.mifosng.platform.exceptions.PlatformApiDataValidationException;
 import org.mifosng.platform.exceptions.PlatformDataIntegrityException;
@@ -33,7 +27,6 @@ import org.mifosng.platform.user.domain.AppUser;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 import org.springframework.beans.factory.annotation.Autowired;
-import org.springframework.format.number.NumberFormatter;
 import org.springframework.stereotype.Service;
 
 @Service
@@ -770,7 +763,7 @@ public class ReadWriteNonCoreDataServiceImpl implements
 					"validation.msg.validation.errors.exist",
 					"Validation errors exist.", dataValidationErrors);
 		}
-
+	    
 		if (!StringUtils.isEmpty(paramValue)) {
 
 			if (columnHeader.getColumnValuesNew().size() > 0) {
@@ -821,22 +814,23 @@ public class ReadWriteNonCoreDataServiceImpl implements
 								+ " (neither varchar nor int)");
 			}
 
+		    JsonParserHelper helper = new JsonParserHelper();
+		    
 			if (columnHeader.getColumnDisplayTypeNew().equals("DATE"))
-				paramValue = convertFrom(paramValue,
+				paramValue = helper.convertFrom(paramValue,
 						columnHeader.getColumnName(), dateFormat,
 						clientApplicationLocale).toString();
 
 			if (columnHeader.getColumnDisplayTypeNew().equals("INTEGER"))
-				paramValue = convertToInteger(paramValue,
+				paramValue = helper.convertToInteger(paramValue,
 						columnHeader.getColumnName(), clientApplicationLocale)
 						.toString();
 
 			if (columnHeader.getColumnDisplayTypeNew().equals("DECIMAL"))
-				paramValue = convertFrom(paramValue,
+				paramValue = helper.convertFrom(paramValue,
 						columnHeader.getColumnName(), clientApplicationLocale)
 						.toString();
-
+			//logger.info("Converted Value: " + paramValue + " - was: " + pValue);
-			logger.info("Converted Value: " + paramValue + " - was: " + pValue);
 
 		}
 
@@ -873,217 +867,4 @@ public class ReadWriteNonCoreDataServiceImpl implements
 		return true;
 	}
 
-	private LocalDate convertFrom(final String dateAsString,
-			final String parameterName, final String dateFormat,
-			final Locale clientApplicationLocale) {
-
-		if (StringUtils.isBlank(dateFormat) || clientApplicationLocale == null) {
-
-			List<ApiParameterError> dataValidationErrors = new ArrayList<ApiParameterError>();
-			if (StringUtils.isBlank(dateFormat)) {
-				String defaultMessage = new StringBuilder(
-						"The parameter '"
-								+ parameterName
-								+ "' requires a 'dateFormat' parameter to be passed with it.")
-						.toString();
-				ApiParameterError error = ApiParameterError.parameterError(
-						"validation.msg.missing.dateFormat.parameter",
-						defaultMessage, parameterName);
-				dataValidationErrors.add(error);
-			}
-			if (clientApplicationLocale == null) {
-				String defaultMessage = new StringBuilder(
-						"The parameter '"
-								+ parameterName
-								+ "' requires a 'locale' parameter to be passed with it.")
-						.toString();
-				ApiParameterError error = ApiParameterError.parameterError(
-						"validation.msg.missing.locale.parameter",
-						defaultMessage, parameterName);
-				dataValidationErrors.add(error);
-			}
-			throw new PlatformApiDataValidationException(
-					"validation.msg.validation.errors.exist",
-					"Validation errors exist.", dataValidationErrors);
-		}
-
-		LocalDate eventLocalDate = null;
-		if (StringUtils.isNotBlank(dateAsString)) {
-			try {
-				// Locale locale = LocaleContextHolder.getLocale();
-				eventLocalDate = DateTimeFormat
-						.forPattern(dateFormat)
-						.withLocale(clientApplicationLocale)
-						.parseLocalDate(
-								dateAsString
-										.toLowerCase(clientApplicationLocale));
-			} catch (IllegalArgumentException e) {
-				List<ApiParameterError> dataValidationErrors = new ArrayList<ApiParameterError>();
-				ApiParameterError error = ApiParameterError.parameterError(
-						"validation.msg.invalid.date.format", "The parameter "
-								+ parameterName
-								+ " is invalid based on the dateFormat: '"
-								+ dateFormat + "' and locale: '"
-								+ clientApplicationLocale + "' provided:",
-						parameterName, dateAsString, dateFormat);
-				dataValidationErrors.add(error);
-
-				throw new PlatformApiDataValidationException(
-						"validation.msg.validation.errors.exist",
-						"Validation errors exist.", dataValidationErrors);
-			}
-		}
-
-		return eventLocalDate;
-	}
-
-	private Integer convertToInteger(final String numericalValueFormatted,
-			final String parameterName, final Locale clientApplicationLocale) {
-
-		if (clientApplicationLocale == null) {
-
-			List<ApiParameterError> dataValidationErrors = new ArrayList<ApiParameterError>();
-			String defaultMessage = new StringBuilder("The parameter '"
-					+ parameterName
-					+ "' requires a 'locale' parameter to be passed with it.")
-					.toString();
-			ApiParameterError error = ApiParameterError.parameterError(
-					"validation.msg.missing.locale.parameter", defaultMessage,
-					parameterName);
-			dataValidationErrors.add(error);
-
-			throw new PlatformApiDataValidationException(
-					"validation.msg.validation.errors.exist",
-					"Validation errors exist.", dataValidationErrors);
-		}
-
-		try {
-			Integer number = null;
-
-			if (StringUtils.isNotBlank(numericalValueFormatted)) {
-
-				String source = numericalValueFormatted.trim();
-
-				NumberFormat format = NumberFormat
-						.getInstance(clientApplicationLocale);
-				DecimalFormat df = (DecimalFormat) format;
-				DecimalFormatSymbols symbols = df.getDecimalFormatSymbols();
-				df.setParseBigDecimal(true);
-
-				// http://bugs.sun.com/view_bug.do?bug_id=4510618
-				char groupingSeparator = symbols.getGroupingSeparator();
-				if (groupingSeparator == '\u00a0') {
-					source = source.replaceAll(" ",
-							Character.toString('\u00a0'));
-				}
-
-				Number parsedNumber = df.parse(source);
-
-				double parsedNumberDouble = parsedNumber.doubleValue();
-				int parsedNumberInteger = parsedNumber.intValue();
-
-				if (source.contains(Character.toString(symbols
-						.getDecimalSeparator()))) {
-					throw new ParseException(source, 0);
-				}
-
-				if (!Double.valueOf(parsedNumberDouble).equals(
-						Double.valueOf(Integer.valueOf(parsedNumberInteger)))) {
-					throw new ParseException(source, 0);
-				}
-
-				number = parsedNumber.intValue();
-			}
-
-			return number;
-		} catch (ParseException e) {
-
-			List<ApiParameterError> dataValidationErrors = new ArrayList<ApiParameterError>();
-			ApiParameterError error = ApiParameterError
-					.parameterError(
-							"validation.msg.invalid.integer.format",
-							"The parameter "
-									+ parameterName
-									+ " has value: "
-									+ numericalValueFormatted
-									+ " which is invalid integer value for provided locale of ["
-									+ clientApplicationLocale.toString() + "].",
-							parameterName, numericalValueFormatted,
-							clientApplicationLocale);
-			dataValidationErrors.add(error);
-
-			throw new PlatformApiDataValidationException(
-					"validation.msg.validation.errors.exist",
-					"Validation errors exist.", dataValidationErrors);
-		}
-	}
-
-	private BigDecimal convertFrom(final String numericalValueFormatted,
-			final String parameterName, final Locale clientApplicationLocale) {
-
-		if (clientApplicationLocale == null) {
-
-			List<ApiParameterError> dataValidationErrors = new ArrayList<ApiParameterError>();
-			String defaultMessage = new StringBuilder("The parameter '"
-					+ parameterName
-					+ "' requires a 'locale' parameter to be passed with it.")
-					.toString();
-			ApiParameterError error = ApiParameterError.parameterError(
-					"validation.msg.missing.locale.parameter", defaultMessage,
-					parameterName);
-			dataValidationErrors.add(error);
-
-			throw new PlatformApiDataValidationException(
-					"validation.msg.validation.errors.exist",
-					"Validation errors exist.", dataValidationErrors);
-		}
-
-		try {
-			BigDecimal number = null;
-
-			if (StringUtils.isNotBlank(numericalValueFormatted)) {
-
-				String source = numericalValueFormatted.trim();
-
-				NumberFormat format = NumberFormat
-						.getNumberInstance(clientApplicationLocale);
-				DecimalFormat df = (DecimalFormat) format;
-				DecimalFormatSymbols symbols = df.getDecimalFormatSymbols();
-				// http://bugs.sun.com/view_bug.do?bug_id=4510618
-				char groupingSeparator = symbols.getGroupingSeparator();
-				if (groupingSeparator == '\u00a0') {
-					source = source.replaceAll(" ",
-							Character.toString('\u00a0'));
-				}
-
-				NumberFormatter numberFormatter = new NumberFormatter();
-				Number parsedNumber = numberFormatter.parse(source,
-						clientApplicationLocale);
-				number = BigDecimal.valueOf(Double.valueOf(parsedNumber
-						.doubleValue()));
-			}
-
-			return number;
-		} catch (ParseException e) {
-
-			List<ApiParameterError> dataValidationErrors = new ArrayList<ApiParameterError>();
-			ApiParameterError error = ApiParameterError
-					.parameterError(
-							"validation.msg.invalid.decimal.format",
-							"The parameter "
-									+ parameterName
-									+ " has value: "
-									+ numericalValueFormatted
-									+ " which is invalid decimal value for provided locale of ["
-									+ clientApplicationLocale.toString() + "].",
-							parameterName, numericalValueFormatted,
-							clientApplicationLocale);
-			dataValidationErrors.add(error);
-
-			throw new PlatformApiDataValidationException(
-					"validation.msg.validation.errors.exist",
-					"Validation errors exist.", dataValidationErrors);
-		}
-	}
-
 }