[SalesForce] Account Merge – Opportunity is not updated / touched

Could someone who knows better verify:

I just tested and it seems to me that if I merge –

Account 1 with 2 opps (destination)
Account 2 with 3 opps

…that the resultant Account 1 with all five opps does NOT benefit from having the Opps it obtained actually being "touched" (updated, edit/save, etc) officially (so no triggers/etc run). Is this true?

Is there a simple way to make this happen, perhaps a simple trigger that would say "if I detect my AccountID has changed, touch me" (at the Opp level)? Since it's not doing it by default, I am unclear how to code such a thing if SF itself doesn't even recognize that the Opp record has been updated (AccountID reference has changed after Merge).

Thanks!

Best Answer

From the Apex Developer's Guide:

Merge events do not fire their own trigger events. Instead, they fire delete and update events as follows:

Deletion of losing records A single merge operation fires a single delete event for all records that are deleted in the merge. To determine which records were deleted as a result of a merge operation use the MasterRecordId field in Trigger.old. When a record is deleted after losing a merge operation, its MasterRecordId field is set to the ID of the winning record. The MasterRecordId field is only set in after delete trigger events. If your application requires special handling for deleted records that occur as a result of a merge, you need to use the after delete trigger event.

Update of the winning record A single merge operation fires a single update event for the winning record only. Any child records that are reparented as a result of the merge operation do not fire triggers. For example, if two contacts are merged, only the delete and update contact triggers fire. No triggers for records related to the contacts, such as accounts or opportunities, fire.

The following is the order of events when a merge occurs:

The before delete trigger fires.

The system deletes the necessary records due to the merge, assigns new parent records to the child records, and sets the MasterRecordId field on the deleted records. )

The after delete trigger fires.

The system does the specific updates required for the master record. Normal update triggers apply.

Thus you could have a before delete trigger on the deletion of the losing records and figure out the children that will be affected. I suspect that you might need to have some co-ordination between the before and after delete triggers, such that the before figured out the affected children of a delete, and the after confirmed that they were being deleted as part of a merge and took appropriate action.

Related Solutions

[SalesForce] Make Validation Rule bypass if TRIGGER is run

Use a hierarchical custom setting.

The setting just has two fields.

Location -> Lookup to user/profile
Skip_Validation__c -> Set it to true to skip validation.

Update your validation rules to not fire when Skip validation = true for the custom setting.

&& NOT($Setup.MyCustomSetting__c.Skip_Validation__c)

As the last step, your trigger shuts off validation at the start and enables it at the end.

MyCustomSetting__c tempSkipValidation = 
  MyCustomSetting__c.getInstance();

if(tempSkipValidation == null) {
  tempSkipValidation = new MyCustomSetting__c();
}

tempSkipValidation.Skip_Validation__c = true;
upsert tempSkipValidation;

//WHATEVER TRIGGER NORMALLY DOES HERE

tempSkipValidation.Skip_Validation__c = false;
update tempSkipValidation;

[SalesForce] Avoiding SOQL limits in a recursive method

Unfortunately querying hierarchies can be kind of a pain, and you're current approach scales linearly with the hierarchy size, which means assuming no other code is sharing your limits, you can deal with a max hierarchy size of 100. You'll need to re-architect this method to remove the recursion for the query portion.

The basic approach is to query to every account that has that parent at any level, and then build a map by parent. Then you can recurse down from the parent to build out a list of childs.

Here's an example from an old project

/*
Developer: Ralph Callaway <ralph@callawaycloudconsulting.com>
Description:
    Representation of an account hierarchy.
*/
public class AccountHierarchy {

    /* Variables */

    private Boolean accountsLoaded = false;
    private Boolean hierarchyLoaded = false;
    private Id refId;
    private Set<String> queryFields = new Set<String>();
    private static Set<String> alwaysQueryFields = new Set<String>{ 'name', 'parentid' }; 

    /* Properties */

    private List<Account> accounts { 
        get {
            if(!accountsLoaded) {
                loadAccounts(); 
            }
            return accounts;
        }
        set;
    }

    public Integer limitAmt { get; set; }

    public String whereClause { 
        get;
        set {
            if(whereClause != value) {
                whereClause = value;
                accountsLoaded = false;
                hierarchyLoaded = false;
            }
        } 
    }

    public Node root {
        get {
            if(whereClause != null) {
                root = null;
            } else if(!hierarchyLoaded) {
                buildHierarchy();
            }
            return root;
        }
        private set;
    }

    /* Constructor */

    public AccountHierarchy(Id refId) {
        this.refId = refId;
    }

    /* Public Methods */

    public void addQueryField(String field) {
        if(field != null) {
            Boolean newField = queryFields.add(field.toLowerCase());
            if(newField) {
                accountsLoaded = false; 
                hierarchyLoaded = false;
            }   
        }
    }

    // returns by value
    public Set<String> getQueryFields() {
        return queryFields.clone();
    }

    public List<Account> toAccountList() {
        return (root == null) ? accounts : root.toAccountList();
    }

    public List<Id> toIdList() {
        List<Id> idList = new List<Id>();
        if(root == null) {
            Map<Id, Account> tempMap = new Map<Id, Account>(accounts);
            idList.addAll(tempMap.keySet());
        } else {
            idList = root.toIdList();
        }
        return idList;
    }

    public List<Node> toList() {
        return (root == null) ? new List<Node>() : root.toList();
    }

    // returns true if value present, false if value not found
    public Boolean removeQueryField(String field) {
        if(field != null) {
            field = field.toLowerCase();
            if(queryFields.contains(field)) {
                queryFields.remove(field);
                return true;
            }
        }
        return false;
    }

    public void setRefToTop() {
        refId = getTopId(refId);
    }

    /* Static Public Methods */

    public static Id getTopId(Id startId) {
        Account account = [
            select
                  parentId
                , parent.parentId
                , parent.parent.parentId
                , parent.parent.parent.parentId
                , parent.parent.parent.parent.parentId
                , parent.parent.parent.parent.parent.parentId
            from Account
            where id = :startId
        ];
        if(account.parent.parent.parent.parent.parent.parentId != null) {
            return account.parent.parent.parent.parent.parent.parentId;
        } else if(account.parent.parent.parent.parent.parentId != null) {
            return account.parent.parent.parent.parent.parentId;
        } else if(account.parent.parent.parent.parentId != null) {
            return account.parent.parent.parent.parentId;
        } else if(account.parent.parent.parentId != null) {
            return account.parent.parent.parentId;
        } else if(account.parent.parentId != null) {
            return account.parent.parentId;
        } else if(account.parentId != null) {
            return account.parentId;
        } else {
            return account.id;
        }
    }

    /* Support Methods */

    private void buildHierarchy() {
        hierarchyLoaded = true;

        // bail if we don't have any accounts to build
        if(accounts.isEmpty()) return;

        // query all accounts down the hierarchy and organize by their parent
        Map<Id, List<Node>> nodeByParent = new Map<Id, List<Node>>();
        for(Account account : accounts) {
            if(!nodeByParent.containsKey(account.parentId))
                nodeByParent.put(account.parentId, new List<Node>());
            Node accountNode = new Node(account);
            if(account.id == refId)
                root = accountNode; 
            nodeByParent.get(account.parentId).add(new Node(account));
        }

        // build the hierarchy one level at a time
        root.depth = 1;
        recursiveNodeBuild(root, nodeByParent);
    }

    private String buildQuery() {
        String selectFields = '';
        Set<String> allFields = new Set<String>();
        allFields.addAll(alwaysQueryFields);
        allFields.addAll(queryFields);
        for(String field : allFields) {
            selectFields += ', ' + field;
        }
        selectFields = selectFields.substring(2);
        String innerWhereClause = ''
            + ' where (id = \'' + refId + '\''
            + ' or parentId = \'' + refId + '\''
            + ' or parent.parentId = \'' + refId + '\''
            + ' or parent.parent.parentId = \'' + refId + '\''
            + ' or parent.parent.parent.parentId = \'' + refId + '\''
            + ' or parent.parent.parent.parent.parentId = \'' + refId + '\''
            + ' or parent.parent.parent.parent.parent.parentId = \'' + refId + '\')';

        String queryString = 'select ' + selectFields + ' from Account' + innerWhereClause;

        if(whereClause != null) {
            whereClause = whereClause.toLowerCase();
            whereClause = whereClause.replace('where', '');
            queryString += ' and (' + whereClause + ')';
        }

        queryString += ' order by name asc';

        if(limitAmt != null) {
            queryString += ' limit ' + limitAmt;
        }

        return queryString;
    }

    private void loadAccounts() {
        accountsLoaded = true;
        accounts = (List<Account>) Database.query(buildQuery());
    }

    private void recursiveNodeBuild(Node currentNode, Map<Id, List<Node>> nodesByParent) {
        if(nodesByParent.containsKey(currentNode.id)) {
            for(Node child : nodesByParent.get(currentNode.id)) {
                child.depth = currentNode.depth + 1;
                currentNode.children.add(child);
                recursiveNodeBuild(child, nodesByParent);
            }
        }
    }

    /* Inner Classs */

    public class Node {

        // variables
        public Integer depth { get; set; } // root node has depth of 1
        public String name { get; private set; }
        public String id { get; private set; }
        public Account record { get; set; }
        public List<Node> children { get; set; }

        // constructor
        public Node(Account record) {
            this.record = record;
            name = record.name;
            id = record.id;
            depth = -1; // -1 indicates depth has not been set
            children = new List<Node>();
        }

        // methods
        public List<Account> toAccountList() {
            List<Account> accountList = new Account[] { record };
            for(Node child : children) {
                accountList.addAll(child.toAccountList());
            }   
            return accountList;
        }

        public List<Id> toIdList() {
            List<Id> toIdList = new Id[] { id };
            for(Node child : children) {
                toIdList.addAll(child.toIdList());
            }
            return toIdList;
        }

        public List<Node> toList() {
            List<Node> nodeList = new Node[] { this };
            for(Node child : children) {
                nodeList.addAll(child.toList());
            }
            return nodeList;
        }
    }
}

Best Answer

Related Solutions

[SalesForce] Make Validation Rule bypass if TRIGGER is run

[SalesForce] Avoiding SOQL limits in a recursive method

Related Topic