Salesforce Apex Triggers Real Time Scenarios

This blog contains 5 Salesforce Apex Triggers Real Time Scenarios that will help you to get an idea about the Apex Triggers for your interviews and day job.

Business Use Case:

Our sales team spends a significant amount of time manually updating contact information and opportunities when accounts become inactive. This process is inefficient and error-prone. Additionally, it delays efforts to focus on converting qualified leads.

Code –

Trigger

trigger accTrg on Account (after update)
{
if(trigger.isAfter && trigger.isUpdate)
{
AccountTriggerHandler.trgMethod(trigger.new,trigger.oldMap);
}
}

Handler Class

public class AccountTriggerHandler
{
public static void trgMethod(List<Account> newList,Map<Id,Account> oldMap)
{
Set<Id> parentAccIds = new Set<Id>();
Account oldAcc = new Account();</p>
if(!newList.isEmpty())
{
for(Account newAcc : newList)
{
if(oldMap != null)
{
oldAcc = oldMap.get(newAcc.Id);

if(oldAcc.Status__c == 'Active' && newAcc.Status__c == 'Inactive')
{
parentAccIds.add(newAcc.Id);
}
}
}
}
if(!parentAccIds.isEmpty())
{
List<Contact> relatedConList = [Select Id,Do_Not_Contact__c,AccountId from Contact where AccountId IN : parentAccIds
and Do_Not_Contact__c = false];

List<Opportunity> relatedOppList = [Select Id,AccountId from Opportunity where AccountId IN : parentAccIds
and Stagename != 'Closed Won'];

List<Contact> listToUpdate = new List<Contact>();

if(!relatedConList.isEmpty())
{
for(Contact con : relatedConList)
{
con.Do_Not_Contact__c = true;
listToUpdate.add(con);
}
}

if(!relatedOppList.isEmpty())
{
delete relatedOppList;
}

if(!listToUpdate.isEmpty())
{
update listToUpdate;
}

}
}
}

Business Use Case:

A company wants to improve its customer relationship management by automatically updating the rating of customer accounts based on the number of closed cases associated with them. The company categorizes accounts into “Hot,” “Warm,” or “Cold” based on their engagement level, determined by the number of closed cases.

Requirements:

Automatically update the rating of customer accounts based on the number of closed cases associated with them.
Accounts with more than 5 closed cases are considered “Hot,” indicating high engagement.
Accounts with 3 to 5 closed cases are considered “Warm,” indicating moderate engagement.
Accounts with fewer than 3 closed cases are considered “Cold,” indicating low engagement.
The trigger should only consider cases with a status of “Closed” when calculating the rating.

code –

Trigger


trigger caseTrg on Case (after insert,after Update,after Delete,after Undelete)
{
if(trigger.isAfter && (trigger.isInsert || trigger.isUndelete))
{
CaseTriggerHandler.trgMethod(trigger.new, null);
}
else if(trigger.isAfter && trigger.isUpdate)
{
CaseTriggerHandler.trgMethod(trigger.new, trigger.oldMap);
}
else if(trigger.isAfter && trigger.isDelete)
{
CaseTriggerHandler.trgMethod(trigger.old, null);
}

}

Handler Class


public class CaseTriggerHandler
{
public static void trgMethod(List<Case> newCaseList,Map<Id,Case> oldCaseMap)
{
Set<Id> parentAccountIds = new Set<Id>();
Case oldCase = new Case();
List<Account> listToUpdate = new List<Account>();

if(!newCaseList.isEmpty())
{
for(Case newCase : newCaseList)
{
if(oldCaseMap != null)
{
oldCase = oldCaseMap.get(newCase.Id);

if(oldCase.AccountId != newCase.AccountId)
{
parentAccountIds.add(oldCase.AccountId);
parentAccountIds.add(newCase.AccountId);
}
else
{
parentAccountIds.add(newCase.AccountId);
}
}
else
{
parentAccountIds.add(newCase.AccountId);
}
}
}
if(!parentAccountIds.isEmpty())
{
List<Account> accList = [Select Id,Rating from Account where Id IN : parentAccountIds];
Map<Id,List<Case>> caseCountMap = new Map<Id,List<Case>>();

List<Case> relatedCaseList = [Select Id,AccountId,Status from Case where AccountId IN : parentAccountIds
and Status = 'Closed'];
if(!relatedCaseList.isEmpty())
{
for(Case relatedCase : relatedCaseList)
{
if(!caseCountMap.containsKey(relatedCase.AccountId))
{
caseCountMap.put(relatedCase.AccountId,new List<Case>());
}
caseCountMap.get(relatedCase.AccountId).add(relatedCase);
}
}
if(!accList.isEmpty())
{
for(Account acc : accList)
{
Integer closedCase = caseCountMap.containsKey(acc.Id) ? caseCountMap.get(acc.Id).size() : 0;

String accountRating;

if(closedCase > 5)
{
accountRating = 'Hot';
}
else if(closedCase > 2)
{
accountRating = 'Warm';
}
else
{
accountRating = 'Cold';
}
acc.Rating = accountRating;
listToUpdate.add(acc);
}
}
if(!listToUpdate.isEmpty())
{
update listToUpdate;
}
}
}
}

Business Use Case:

A company wants to streamline its lead conversion process within its Salesforce CRM system. They want to ensure that when a lead is converted into an account, contact, and opportunity, certain fields are updated automatically for better tracking and reporting.

Description :

If a lead is marked as converted then for each converted lead, the trigger performs the following actions:
1. If an account is associated with the converted lead, it updates the Active__c field of the account to ‘Yes’.
2. If a contact is associated with the converted lead, it sets the Lead_Contact__c field of the contact to true.
3. If an opportunity is associated with the converted lead, it updates the opportunity’s description with the lead’s name for better tracking.

Code :

Trigger

trigger leadTrg on Lead (after update)
{
if(trigger.isAfter && trigger.isUpdate)
{
LeadTriggerHandler.trgMethod(trigger.new);
}
}

Handler Class

public class LeadTriggerHandler
{
public static void trgMethod(List<Lead> newLeadList)
{
Set<Id> convertedLeadIds = new Set<Id>();
List<Account> listToUpdateAcc = new List<Account>();
List<Contact> listToUpdateCon = new List<Contact>();
List<Opportunity> listToUpdateOpp = new List<Opportunity>();

if(!newLeadList.isEmpty())
{
for(Lead newLead : newLeadList)
{
if(newLead.IsConverted)
{
convertedLeadIds.add(newLead.Id);
}
}
}
if(!convertedLeadIds.isEmpty())
{
Map<Id,Lead> leadMap = new Map<Id,Lead>([Select Id,Name,ConvertedAccountId,ConvertedContactId,ConvertedOpportunityId
from Lead where Id IN : convertedLeadIds]);

for(Lead leadRcd : leadMap.values())
{
if(leadRcd.ConvertedAccountId != null)
{
Account acc = new Account();
acc.Id = leadRcd.ConvertedAccountId;
acc.Active__c = 'Yes';
listToUpdateAcc.add(acc);
}

if(leadRcd.ConvertedContactId != null)
{
Contact con = new Contact();
con.Id = leadRcd.ConvertedContactId;
con.Lead_Contact__c = true;
listToUpdateCon.add(con);
}
if(leadRcd.ConvertedOpportunityId != null)
{
Opportunity opp = new Opportunity();
opp.Id = leadRcd.ConvertedOpportunityId;
opp.Description = 'Converted Lead Name : '+leadRcd.Name;
listToUpdateOpp.add(opp);
}
}

if(!listToUpdateAcc.isEmpty())
{
update listToUpdateAcc;
}
if(!listToUpdateCon.isEmpty())
{
update listToUpdateCon;
}
if(!listToUpdateOpp.isEmpty())
{
update listToUpdateOpp;
}
}
}
}

Salesforce Apex Trigger Scenario based Interview Questions

Business Use Case:

In many businesses, Contacts are associated with specific Accounts, and Account records are categorized into various types or classifications. There might be a requirement to synchronize or maintain consistency between the Contact’s type and the type of the associated Account. This ensures that Contacts are appropriately categorized based on the nature of their relationship with the Account.

Scenario:

Consider a scenario in a Sales Management System where Contacts are linked to Accounts. Each Account is classified into different categories like “Lead,” “Customer,” or “Partner,” representing the stage of the business relationship. When an Account’s type changes, it’s crucial to update the Contact records associated with it to reflect the same type for consistency and accurate reporting.

Use Case Implementation:

The provided Apex trigger handler facilitates this synchronization process by automatically updating the Contact_Type__c field on Contact records based on changes to the related Account’s record type. Here’s how the code accomplishes this:

Code :

Trigger

trigger conTrg on Contact (before insert,before Update)
{
if(trigger.isBefore && trigger.isInsert )
{
ContactTriggerHandler.trgMethod(trigger.new, null);
}
else if(trigger.isBefore && trigger.isUpdate)
{
ContactTriggerHandler.trgMethod(trigger.new, trigger.oldMap);
}

}

Handler Class

public class ContactTriggerHandler
{
public static void trgMethod(List<Contact> newConList,Map<Id,Contact> oldConMap)
{
Set<Id> parentAccIds = new Set<Id>();
Map<Id,String> accMap = new Map<Id,String>();

if(!newConList.isEmpty() && oldConMap == null)
{
for(Contact newCon : newConList)
{
if(newCon.AccountId != null)
{
parentAccIds.add(newCon.AccountId);
}
}

if(!parentAccIds.isEmpty())
{
for(Account acc : [Select Id,RecordType.Name from Account where Id IN : parentAccIds])
{
if(!accMap.containsKey(acc.Id))
{
accMap.put(acc.Id,acc.RecordType.Name);
}
}
if(!newConList.isEmpty())
{
for(Contact con : newConList)
{
if(accMap.containsKey(con.AccountId))
{
String accRecordTypeName = accMap.get(con.AccountId);

if(accRecordTypeName != null)
{
if(accRecordTypeName == 'Lead' || accRecordTypeName == 'Customer' || accRecordTypeName == 'Partner')
{
con.Contact_Type__c = accRecordTypeName;
}
}
}
}
}
}
}
else
{
if(!newConList.isEmpty())
{
for(Contact conRcd : newConList)
{
Contact oldCon = oldConMap.get(conRcd.Id);

if(conRcd.Contact_Type__c != oldCon.Contact_Type__c)
{
String accRecordType = accMap.get(conRcd.AccountId);

if(conRcd.Contact_Type__c != accRecordType)
{
conRcd.addError('Contact Type cannot be updated to a value other than account record type');
}
}
}
}
}
}
}

Business Use Case:

A company using Salesforce as its CRM platform to manage customer support cases. They have a requirement to automate certain tasks whenever the status of a case is updated.

Functional Requirements:

Task Status Update: Whenever the status of a case is changed, the corresponding tasks associated with that case should also be updated to reflect the new status.
Account Description Update: Additionally, whenever the status of a case changes, the description of the parent account associated with that case should be updated to include the case number and the new status.

Code

Trigger

trigger caseTrg on Case (after Update)
{
if(trigger.isAfter && trigger.isUpdate)
{
CaseTriggerHandler.trgMethod(trigger.new, trigger.oldMap);
}
}

Handler

public class CaseTriggerHandler
{
public static void trgMethod(List<Case> newCaseList,Map<Id,Case> oldCaseMap)
{
Set<Id> parentAccountIds = new Set<Id>();
Map<Id,String> caseStatusMap = new Map<Id,String>();
List<Task> tasksToUpdate = new List<Task>();
Case oldCase = new Case();
Map<Id,Account> accMap = new Map<Id,Account>();
List<Account> accToUpdate = new List<Account>();

if(!newCaseList.isEmpty())
{
for(Case newCase : newCaseList)
{
if(oldCaseMap != null)
{
oldCase = oldCaseMap.get(newCase.Id);

if(oldCase.Status != newCase.Status)
{
parentAccountIds.add(newCase.AccountId);
caseStatusMap.put(newCase.Id,newCase.Status);
}
}
}
}

if(!caseStatusMap.isEmpty())
{
List<Task> taskList = [Select Id,WhatId,Status from Task where WhatId IN : caseStatusMap.keyset()];

if(!taskList.isEmpty())
{
for(Task tsk : taskList)
{
if(caseStatusMap.containsKey(tsk.WhatId))
{
tsk.Status = caseStatusMap.get(tsk.WhatId);
tasksToUpdate.add(tsk);
}
}
}
if(!tasksToUpdate.isEmpty())
{
update tasksToUpdate;
}
}
if(!parentAccountIds.isEmpty())
{
for(Account acc : [Select Id,Description from Account where Id IN : parentAccountIds])
{
accMap.put(acc.Id,acc);
}

for(Case csRcd : newCaseList)
{
if(accMap.containsKey(csRcd.AccountId))
{
Account acc = accMap.get(csRcd.AccountId);
acc.Description = 'Case Number : '+csRcd.CaseNumber +' '+'Status : '+csRcd.Status;
accToUpdate.add(acc);
}
}
if(!accToUpdate.isEmpty())
{
update accToUpdate;
}
}
}
}

In wrapping up, mastering real-life situations with Salesforce Apex Triggers is crucial for interview prep. These examples offer insights for interviews and day-to-day tasks, helping you showcase your Apex Triggers expertise. Here’s why practicing scenarios is vital:

1. Understanding Concepts: Real-time scenarios clarify Apex Triggers concepts, aiding interview question responses.

2. Problem-Solving Skills: Practice hones your problem-solving abilities, boosting interview confidence.

3. Applying Knowledge: Applying theory to real situations strengthens understanding, aiding interview articulation.

4. Confidence Building: Practice instills confidence, making complex concepts easier to discuss in interviews.

5. Experience Demonstration: Hands-on experience impresses interviewers, demonstrating practical Apex Triggers understanding.

Remember, practicing scenarios is key to interview success. With dedication, you’ll ace those interviews and become a skilled Salesforce developer. Happy coding!

Here is more scenarios/examples that you can use for practice –

30 Salesforce Apex Trigger Examples – Part 1

Want to learn Salesforce Development? Submit the below form you will soon hear from our team –

Share Now

Salesforce Apex Triggers Real Time Scenarios

Business Use Case:

Business Use Case:

Requirements:

Business Use Case:

Description :

Business Use Case:

Scenario:

Use Case Implementation:

Business Use Case:

Functional Requirements:

Badal Chaudhary

Leave a Reply Cancel reply

Learn Salesforce Flows 👇

Prepare for PD1 Exam

Crack the Admin Exam

Book a 1:1 Call 👇

Featured on Apex Hours

Salesforce Apex Triggers Real Time Scenarios

Business Use Case:

Business Use Case:

Requirements:

Business Use Case:

Description :

Business Use Case:

Scenario:

Use Case Implementation:

Business Use Case:

Functional Requirements:

Badal Chaudhary

Similar Posts

Email-to-Case in Salesforce

Repeater Component in Salesforce Flow

Leave a Reply Cancel reply