Link incoming cases to new / existing accounts through apex

Question

I'm trying to link incoming cases (through the UI and through our REST API). Essentially, I'm checking for a combination of first name, last name and email on the incoming case, and if that combination exists on a Person Account - link it to that existing person account, else create a new person account. My only concern is that if there are two or more person accounts (duplicates), the case is linked to one of them - I wish to avoid this step altogether, meaning: If there is more than person account match, don't link the case to any account at all.

public with sharing class CaseAccountLink {
public static void linkCasesToAccount(List<Case> caseList) {

List<Case> casesReceived = [SELECT Id, Web_First_Name__c, Web_Last_Name__c, SuppliedEmail, Privacy_Policy__c, Country__c, Market__c, RecordTypeId
                                FROM Case
                                WHERE Id IN :caseList
                                AND AccountId = null];



    List<String> caseEmails = Collection.of(caseEmails).pluckStrings(Case.SuppliedEmail);

    List<Account> accountsToCheck = [SELECT Id, FirstName, LastName, PersonEmail
                                        FROM Account
                                        WHERE PersonEmail
                                        IN :caseEmails];


    Map<ps_CustomerDetailsKey, Id> existingAccountIdsByKey = new Map<ps_CustomerDetailsKey, Id>(); // Just a custom map

    for (Account eachAcc : accountsToCheck) {
        existingAccountIdsByKey.put(new ps_CustomerDetailsKey(eachAcc.FirstName, eachAcc.LastName, eachAcc.PersonEmail), eachAcc.Id);
    }

    Map<ps_CustomerDetailsKey, Account> newAccountsByKey = new 
    Map<ps_CustomerDetailsKey, Account>();  
    List<Case> linkCaseToAccount = new List<Case>();
    List<Case> casesToUpdate = new List<Case>();


    for (Case eachCase :casesReceived) {
        ps_CustomerDetailsKey caseKey = new ps_CustomerDetailsKey(eachCase.Web_First_Name__c, eachCase.Web_Last_Name__c, eachCase.SuppliedEmail);

        Id foundAccountId = existingAccountIdsByKey.get(caseKey);
        if (foundAccountId != null) {
            // The case maps to an account and the foundAccountId specifies which one
            eachCase.AccountId = foundAccountId;

            linkCaseToAccount.add(eachCase);
            casesToUpdate.add(eachCase);

        } else {
            // No account for the case is found
            Account newAccount = newAccountsByKey.get(caseKey);
            if (newAccount == null) {
                newAccountsByKey.put(caseKey,
                    new Account(
                        FirstName = eachCase.Web_First_Name__c,
                        LastName = eachCase.Web_Last_Name__c,
                        PersonEmail = eachCase.SuppliedEmail
                ));
            }
        }
    }

    Database.insert(newAccountsByKey.values(), false);

    // newly created cases (and accounts) that couldn't be linked
    // needs to be re-checked and linked
    for (Case eachCase : casesReceived) {
        ps_CustomerDetailsKey key = new ps_CustomerDetailsKey(eachCase.Web_First_Name__c, eachCase.Web_Last_Name__c, eachCase.SuppliedEmail);
        Account newAccount = newAccountsByKey.get(key);
        if (newAccount != null) {
            // Should always be the case!
            eachCase.AccountId = newAccount.Id;

            casesToUpdate.add(eachCase);
        }
    }   
    update casesToUpdate;
 }
}

ps_CustomerDetailsKey:

public class ps_CustomerDetailsKey {
    List<Object> key;

public ps_CustomerDetailsKey(String first, String last, String email) {
    this.key = new List<Object>{ first, last, email };
}


public Boolean equals(Object other) {
    if(other instanceof ps_CustomerDetailsKey) {
        return this.key.equals(((ps_CustomerDetailsKey) other).key);
    }
    return false;
}

public override Integer hashCode() {
    return key.hashCode();
}

public String getFirst() {
    return (String) key [0];
}

public String getLast() {
    return (String) key [1];
}

public String getEmail() {
    return (String) key [2];
}   
}

Answer 1

I see two options here.

1. Convert your Map<ps_CustomerDetailsKey, Id> existingAccountIdsByKey into a Map<ps_CustomerDetailsKey, List<Id>> existingAccountIdsByKey - that is, a multimap. Accumulate Account ids for each composite key. Then, alter your logic slightly:

   List<Id> foundAccountIds = existingAccountIdsByKey.get(caseKey);
   if (foundAccountIds != null && foundAccountIds.size() == 1) {
       eachCase.AccountId = foundAccountIds[0];
   

2. Implement a separate Set<ps_CustomerDetailsKey> duplicatedKeys. As you're processing Person Accounts, add keys to this Set if their keys are already represented:

   for (Account eachAcc : accountsToCheck) {
       ps_CustomerDetailsKey key = new ps_CustomerDetailsKey(eachAcc.FirstName, eachAcc.LastName, eachAcc.PersonEmail);
   
       if (existingAccountIdsByKey.containsKey(key)) {
           duplicatedKeys.add(key);
       } else {
           existingAccountIdsByKey.put(new ps_CustomerDetailsKey(eachAcc.FirstName, eachAcc.LastName, eachAcc.PersonEmail), eachAcc.Id);
       }
   }
   

   Then, similarly alter your logic:

   Id foundAccountId = (duplicatedKeys.contains(caseKey) ? null : existingAccountIdsByKey.get(caseKey));
   if (foundAccountId != null) {
   

Answer 2

You should be able to check for this when you're building your map. I'd add any key that is a duplicate to a set and then just iterate again over the keyset to remove those values so later on you can essentially "skip" those cases from your logic of creating an account if one doesn't exist.

Set<ps_CustomerDetailsKey> removeDups = new Set<ps_CustomerDetailsKey>();

for (Account eachAcc : accountsToCheck) {
    ps_CustomerDetailsKey detail = new ps_CustomerDetailsKey(eachAcc.FirstName, eachAcc.LastName, eachAcc.PersonEmail);
    //if it was already added, just add it to the set to remove later
    if(existingAccountIdsByKey.contains(detail){
        removeDups.add(detail);        
    } else {
        existingAccountIdsByKey.put(detail, eachAcc.Id);
    }

    //Loop through and remove the keys that were duplicates
    for(ps_CustomerDetailsKey key : existingAccountIdsByKey.keySet()){
        if(removeDups.contains(key)){
            existingAccountIdsByKey.remove(key);
        }
    }

Just know that you'll have to change your later code where you retrieve the accountIds by using the key since you deleted those keys above.

Now, you can just add a check here to not even bother with the if/else logic concerning needing to create an account since you want these (the dups) to be null

for (Case eachCase :casesReceived) {
ps_CustomerDetailsKey caseKey = new ps_CustomerDetailsKey(eachCase.Web_First_Name__c, eachCase.Web_Last_Name__c, eachCase.SuppliedEmail);

if(newAccountsByKey.containsKey(caseKey)){

//now do logic around whether newAccount is null and create a case if one doesn't exist
}