1. import java.util.HashMap;
  2. import java.util.Map;
  4. public class UserDataNormalizer {
  6. /**
  7. * Normalizes user data, performs basic sanity checks, and returns a normalized map.
  8. * @param userData A map of user data.
  9. * @return A normalized map of user data or null if normalization fails.
  10. */
  11. public static Map<String, Object> normalizeUserData(Map<String, Object> userData) {
  12. if (userData == null || userData.isEmpty()) {
  13. return null; // Handle null or empty input
  14. }
  16. Map<String, Object> normalizedData = new HashMap<>();
  18. // Normalize and validate user ID
  19. Object userId = userData.get("userId");
  20. if (!(userId instanceof String)) {
  21. System.err.println("Error: userId must be a string.");
  22. return null;
  23. }
  24. normalizedData.put("userId", (String) userId);
  26. // Normalize and validate username
  27. Object username = userData.get("username");
  28. if (!(username instanceof String)) {
  29. System.err.println("Error: username must be a string.");
  30. return null;
  31. }
  32. normalizedData.put("username", (String) username);
  34. // Normalize and validate email
  35. Object email = userData.get("email");
  36. if (!(email instanceof String)) {
  37. System.err.println("Error: email must be a string.");
  38. return null;
  39. }
  40. String normalizedEmail = email.toString().trim().toLowerCase();
  41. if (!normalizedEmail.matches("^[\\w-\\.]+@([\\w-]+\\.)+[\\w-]{2,4}$")) {
  42. System.err.println("Error: Invalid email format.");
  43. return null;
  44. }
  45. normalizedData.put("email", normalizedEmail);
  47. // Normalize and validate age
  48. Object age = userData.get("age");
  49. if (!(age instanceof Integer)) {
  50. System.err.println("Error: age must be an integer.");
  51. return null;
  52. }
  53. int normalizedAge = Math.max(0, Math.min(150, (int) age)); // Ensure age is within reasonable bounds
  54. normalizedData.put("age", normalizedAge);
  56. // Normalize and validate registration date
  57. Object registrationDate = userData.get("registrationDate");
  58. if (!(registrationDate instanceof String)) {
  59. System.err.println("Error: registrationDate must be a string.");
  60. return null;
  61. }
  62. normalizedData.put("registrationDate", registrationDate);
  64. return normalizedData;
  65. }
  67. public static void main(String[] args) {
  68. // Example usage
  69. Map<String, Object> userData = new HashMap<>();
  70. userData.put("userId", "123");
  71. userData.put("username", "JohnDoe");
  72. userData.put("email", "john.doe@example.com");
  73. userData.put("age", 30);
  74. userData.put("registrationDate", "2023-01-15");
  76. Map<String, Object> normalizedData = normalizeUserData(userData);
  78. if (normalizedData != null) {
  79. System.out.println("Normalized User Data: " + normalizedData);
  80. } else {
  81. System.out.println("Normalization failed.");
  82. }
  84. //Example of failure
  85. Map<String, Object> badData = new HashMap<>();
  86. badData.put("userId", 123);
  87. badData.put("username", "JohnDoe");
  88. badData.put("email", 123);
  90. Map<String, Object> normalizedBadData = normalizeUserData(badData);
  91. if (normalizedBadData == null) {
  92. System.out.println("Bad data normalization failed as expected");
  93. }
  96. }
  97. }

Add your comment