Adapted V3 Identity Map clases to the new endpoint

aulme · aulme · commit ec2777958b4e · 2025-05-30T19:55:31.000+08:00
diff --git a/src/main/java/com/uid2/client/IdentityMapV3Helper.java b/src/main/java/com/uid2/client/IdentityMapV3Helper.java
@@ -24,7 +24,7 @@ public EnvelopeV2 createEnvelopeForIdentityMapRequest(IdentityMapV3Input identit
      * @param responseString the response body returned by a call to <a href="https://unifiedid.com/docs/endpoints/post-identity-map">/identity/map</a>
      * @param envelope the EnvelopeV2 instance returned by {@link #createEnvelopeForIdentityMapRequest}
      * @param identityMapInput the same instance that was passed to {@link #createEnvelopeForIdentityMapRequest}.
-     * @return an IdentityMapResponse instance
+     * @return an IdentityMapV3Response instance
      */
     public IdentityMapV3Response createIdentityMapResponse(String responseString, EnvelopeV2 envelope, IdentityMapV3Input identityMapInput) {
         String decryptedResponseString = uid2Helper.decrypt(responseString, envelope.getNonce());
diff --git a/src/main/java/com/uid2/client/IdentityMapV3Input.java b/src/main/java/com/uid2/client/IdentityMapV3Input.java
@@ -2,99 +2,112 @@
 
 import com.google.gson.annotations.SerializedName;
 
-import java.util.ArrayList;
-import java.util.Collections;
-import java.util.HashMap;
-import java.util.List;
+import java.util.*;
 
 public class IdentityMapV3Input {
     /**
      * @param emails a list of normalized or unnormalized email addresses
-     * @return a IdentityMapInput instance, to be used in {@link IdentityMapHelper#createEnvelopeForIdentityMapRequest}
+     * @return a IdentityMapV3Input instance, to be used in {@link IdentityMapHelper#createEnvelopeForIdentityMapRequest}
      */
-    public static IdentityMapV3Input fromEmails(Iterable<String> emails) {
-        return new IdentityMapV3Input(IdentityType.Email, emails, false);
+    public static IdentityMapV3Input fromEmails(List<String> emails) {
+        return new IdentityMapV3Input().withEmails(emails);
     }
 
     /**
-     * @param phones a <a href="https://unifiedid.com/docs/getting-started/gs-normalization-encoding#phone-number-normalization">normalized</a> phone number
-     * @return an IdentityMapInput instance
+     * @param hashedEmails a <a href="https://unifiedid.com/docs/getting-started/gs-normalization-encoding#email-address-normalization">normalized</a> and <a href="https://unifiedid.com/docs/getting-started/gs-normalization-encoding#email-address-hash-encoding">hashed</a> email address
+     * @return an IdentityMapV3Input instance
      */
-    public static IdentityMapV3Input fromPhones(Iterable<String> phones) {
-        return new IdentityMapV3Input(IdentityType.Phone, phones, false);
+    public static IdentityMapV3Input fromHashedEmails(List<String> hashedEmails) {
+        return new IdentityMapV3Input().withHashedEmails(hashedEmails);
     }
 
     /**
-     * @param hashedEmails a <a href="https://unifiedid.com/docs/getting-started/gs-normalization-encoding#email-address-normalization">normalized</a> and <a href="https://unifiedid.com/docs/getting-started/gs-normalization-encoding#email-address-hash-encoding">hashed</a> email address
-     * @return an IdentityMapInput instance
+     * @param phones a <a href="https://unifiedid.com/docs/getting-started/gs-normalization-encoding#phone-number-normalization">normalized</a> phone number
+     * @return an IdentityMapV3Input instance
      */
-    public static IdentityMapV3Input fromHashedEmails(Iterable<String> hashedEmails) {
-        return new IdentityMapV3Input(IdentityType.Email, hashedEmails, true);
+    public static IdentityMapV3Input fromPhones(List<String> phones) {
+        return new IdentityMapV3Input().withPhones(phones);
     }
 
     /**
      * @param hashedPhones a <a href="https://unifiedid.com/docs/getting-started/gs-normalization-encoding#phone-number-normalization">normalized</a> and <a href="https://unifiedid.com/docs/getting-started/gs-normalization-encoding#phone-number-hash-encoding">hashed</a> phone number
-     * @return an IdentityMapInput instance
+     * @return an IdentityMapV3Input instance
      */
-    public static IdentityMapV3Input fromHashedPhones(Iterable<String> hashedPhones) {
-        return new IdentityMapV3Input(IdentityType.Phone, hashedPhones, true);
+    public static IdentityMapV3Input fromHashedPhones(List<String> hashedPhones) {
+        return new IdentityMapV3Input().withHashedPhones(hashedPhones);
     }
 
-    private IdentityMapV3Input(IdentityType identityType, Iterable<String> emailsOrPhones, boolean alreadyHashed) {
-        if (identityType == IdentityType.Email) {
-            hashedNormalizedEmails = new ArrayList<>();
-            for (String email : emailsOrPhones) {
-                if (alreadyHashed) {
-                    hashedNormalizedEmails.add(new Identity(email));
-                } else {
-                    String hashedEmail = InputUtil.normalizeAndHashEmail(email);
-                    hashedNormalizedEmails.add(new Identity(hashedEmail));
-                    addHashedToRawDiiMapping(hashedEmail, email);
-                }
-            }
-        } else {  //phone
-            hashedNormalizedPhones = new ArrayList<>();
-            for (String phone : emailsOrPhones) {
-                if (alreadyHashed) {
-                    hashedNormalizedPhones.add(new Identity(phone));
-                } else {
-                    if (!InputUtil.isPhoneNumberNormalized(phone)) {
-                        throw new IllegalArgumentException("phone number is not normalized: " + phone);
-                    }
-
-                    String hashedNormalizedPhone = InputUtil.getBase64EncodedHash(phone);
-                    addHashedToRawDiiMapping(hashedNormalizedPhone, phone);
-                    hashedNormalizedPhones.add(new Identity(hashedNormalizedPhone));
-                }
-            }
+    private transient final Map<String, List<String>> diiMappings = new HashMap<>();
+
+    @SerializedName("email_hash")
+    private final List<Identity> hashedEmails = new ArrayList<>();
+
+    @SerializedName("phone_hash")
+    private final List<Identity> hashedPhones = new ArrayList<>();
+
+    private IdentityMapV3Input() {}
+
+    public IdentityMapV3Input withHashedEmails(List<String> hashedEmails) {
+        for (String hashedEmail : hashedEmails) {
+            this.hashedEmails.add(new Identity(hashedEmail));
+            addToDiiMappings(hashedEmail, hashedEmail);
+        }
+        return this;
+    }
+
+    public IdentityMapV3Input withHashedPhones(List<String> hashedPhones) {
+        for (String hashedPhone : hashedPhones) {
+            this.hashedPhones.add(new Identity(hashedPhone));
+            addToDiiMappings(hashedPhone, hashedPhone);
         }
+        return this;
     }
 
-    private void addHashedToRawDiiMapping(String hashedDii, String rawDii) {
-        hashedDiiToRawDiis.computeIfAbsent(hashedDii, k -> new ArrayList<>()).add(rawDii);
+    public IdentityMapV3Input withEmails(List<String> emails) {
+        for (String email : emails) {
+            String hash = InputUtil.normalizeAndHashEmail(email);
+            this.hashedEmails.add(new Identity(hash));
+            addToDiiMappings(hash, email);
+        }
+        return this;
     }
 
+    public IdentityMapV3Input withPhones(List<String> phones) {
+        for (String phone : phones) {
+            if (!InputUtil.isPhoneNumberNormalized(phone)) {
+                throw new IllegalArgumentException("phone number is not normalized: " + phone);
+            }
 
-    List<String> getRawDiis(String identifier) {
-        final boolean wasInputAlreadyHashed = hashedDiiToRawDiis.isEmpty();
-        if (wasInputAlreadyHashed)
-            return Collections.singletonList(identifier);
-        return hashedDiiToRawDiis.get(identifier);
+            String hash = InputUtil.getBase64EncodedHash(phone);
+            this.hashedPhones.add(new Identity(hash));
+            addToDiiMappings(hash, phone);
+        }
+        return this;
     }
 
-    @SerializedName("email_hash")
-    private List<Identity> hashedNormalizedEmails;
-    @SerializedName("phone_hash")
-    private List<Identity> hashedNormalizedPhones;
+    private void addToDiiMappings(String hashedDii, String rawDii) {
+        diiMappings.computeIfAbsent(hashedDii, k -> new ArrayList<>()).add(rawDii);
+    }
+
+    List<String> getRawDiis(String identityType, int i) {
+        return diiMappings.get(getEncodedDii(identityType, i));
+    }
+
+    private String getEncodedDii(String identityType, int i) {
+        switch (identityType) {
+            case "email_hash": return hashedEmails.get(i).identity;
+            case "phone_hash": return hashedPhones.get(i).identity;
+        }
+        throw new Uid2Exception("Unexpected identity type: " + identityType);
+    }
 
-    private final transient HashMap<String, List<String>> hashedDiiToRawDiis = new HashMap<>();
 
     private static class Identity {
         @SerializedName("i")
-        private final String i;
+        private final String identity;
 
         public Identity(String value) {
-            this.i = value;
+            this.identity = value;
         }
     }
 }
diff --git a/src/main/java/com/uid2/client/IdentityMapV3Response.java b/src/main/java/com/uid2/client/IdentityMapV3Response.java
@@ -1,88 +1,115 @@
 package com.uid2.client;
 
 import com.google.gson.Gson;
-import com.google.gson.JsonElement;
-import com.google.gson.JsonObject;
 import com.google.gson.annotations.SerializedName;
 
-import java.util.Collections;
 import java.util.HashMap;
 import java.util.List;
+import java.util.Map;
 
 public class IdentityMapV3Response {
     IdentityMapV3Response(String response, IdentityMapV3Input identityMapInput) {
-        JsonObject responseJson = new Gson().fromJson(response, JsonObject.class);
-        status = responseJson.get("status").getAsString();
+        ApiResponse apiResponse = new Gson().fromJson(response, ApiResponse.class);
+        status = apiResponse.status;
 
         if (!isSuccess()) {
             throw new Uid2Exception("Got unexpected identity map status: " + status);
         }
 
-        Gson gson = new Gson();
-        JsonObject body = getBodyAsJson(responseJson);
-
-        Iterable<JsonElement> mapped = getJsonArray(body, "mapped");
-        for (JsonElement identity : mapped) {
-            List<String> rawDiis = getRawDiis(identity, identityMapInput);
-            MappedIdentity mappedIdentity = gson.fromJson(identity, MappedIdentity.class);
-            for (String rawDii : rawDiis) {
-                mappedIdentities.put(rawDii, mappedIdentity);
-            }
-        }
+        populateIdentities(apiResponse.body, identityMapInput);
+    }
 
-        Iterable<JsonElement> unmapped = getJsonArray(body, "unmapped");
-        for (JsonElement identity : unmapped) {
-            List<String> rawDiis = getRawDiis(identity, identityMapInput);
-            UnmappedIdentity unmappedIdentity = gson.fromJson(identity, UnmappedIdentity.class);
-            for (String rawDii : rawDiis) {
-                unmappedIdentities.put(rawDii, unmappedIdentity);
-            }
+    private void populateIdentities(Map<String, List<ApiIdentity>> apiResponse, IdentityMapV3Input identityMapInput) {
+        for (Map.Entry<String, List<ApiIdentity>> identitiesForType : apiResponse.entrySet()) {
+            populateIdentitiesForType(identityMapInput, identitiesForType.getKey(), identitiesForType.getValue());
         }
     }
 
-    private static Iterable<JsonElement> getJsonArray(JsonObject body, String header) {
-        JsonElement jsonElement = body.get(header);
-        if (jsonElement == null) {
-            return Collections.emptyList();
+    private void populateIdentitiesForType(IdentityMapV3Input identityMapInput, String identityType, List<ApiIdentity> identities) {
+        for (int i = 0; i < identities.size(); i++) {
+            ApiIdentity apiIdentity = identities.get(i);
+            List<String> rawDiis = identityMapInput.getRawDiis(identityType, i);
+            for (String rawDii : rawDiis)
+                if (apiIdentity.error != null) {
+                    unmappedIdentities.put(rawDii, new UnmappedIdentity(apiIdentity));
+                } else {
+                    mappedIdentities.put(rawDii, new MappedIdentity(apiIdentity));
+                }
         }
-        return jsonElement.getAsJsonArray();
     }
 
-    private List<String> getRawDiis(JsonElement identity, IdentityMapV3Input identityMapInput) {
-        String identifier = identity.getAsJsonObject().get("identifier").getAsString();
-        return identityMapInput.getRawDiis(identifier);
+    private static IdentityMapV3Input getIdentityMapInput(IdentityMapV3Input identityMapInput) {
+        return identityMapInput;
     }
 
     public boolean isSuccess() {
         return "success".equals(status);
     }
-    static JsonObject getBodyAsJson(JsonObject jsonResponse) {
-        return jsonResponse.get("body").getAsJsonObject();
+
+    static public class ApiResponse {
+        @SerializedName("status")
+        public String status;
+
+        @SerializedName("body")
+        public Map<String, List<ApiIdentity>> body;
+    }
+
+    static public class ApiIdentity {
+        @SerializedName("u")
+        public String currentUid;
+
+        @SerializedName("p")
+        public String previousUid;
+
+        @SerializedName("r")
+        public Long refreshFromSeconds;
+
+        @SerializedName("e")
+        public String error;
     }
 
     static public class MappedIdentity {
-        public MappedIdentity(String rawUid, String bucketId) {
-            this.rawUid = rawUid;
-            this.bucketId = bucketId;
+        public MappedIdentity(String currentUid, String previousUid, Long refreshFromSeconds) {
+            this.currentUid = currentUid;
+            this.previousUid = previousUid;
+            this.refreshFromSeconds = refreshFromSeconds;
         }
 
-        public String getRawUid() {return rawUid;}
-        public String getBucketId() {return bucketId;}
+        public MappedIdentity(ApiIdentity apiIdentity) {
+            this(apiIdentity.currentUid, apiIdentity.previousUid, apiIdentity.refreshFromSeconds);
+        }
+
+        private final String currentUid;
+        private final String previousUid;
+        private final Long refreshFromSeconds;
+
+        public String getCurrentUid() {
+            return currentUid;
+        }
+
+        public String getPreviousUid() {
+            return previousUid;
+        }
 
-        @SerializedName("advertising_id")
-        private final String rawUid;
-        @SerializedName("bucket_id")
-        private final String bucketId;
+        public Long getRefreshFromSeconds() {
+            return refreshFromSeconds;
+        }
     }
 
     static public class UnmappedIdentity {
         public UnmappedIdentity(String reason) {
             this.reason = reason;
         }
 
-        public String getReason() {return reason;}
+        public UnmappedIdentity(ApiIdentity apiIdentity) {
+            this(apiIdentity.error);
+        }
 
         private final String reason;
+
+        public String getReason() {
+            return reason;
+        }
     }
 
     public HashMap<String, MappedIdentity> getMappedIdentities() {
diff --git a/src/test/java/com/uid2/client/IdentityMapV3IntegrationTests.java b/src/test/java/com/uid2/client/IdentityMapV3IntegrationTests.java
