My Trigger Scenario's

 Scenario 1 : Prevent Contact Update by Same User Within 1 Hour ?

Trigger TimeLastmodified on Contact (Before update) {
    Set<Id> contactIds = new Set<Id>();
    for (Contact con : Trigger.new) {
        contactIds.add(con.Id);
    }
    for (Contact newCon : Trigger.new) {
        if (newCon.LastModifiedById == UserInfo.getUserId()) {
            Long minutesSinceLastUpdate = DateTime.now().getTime() - newCon.LastModifiedDate.getTime();
            minutesSinceLastUpdate = minutesSinceLastUpdate / (60 * 1000);
            if (minutesSinceLastUpdate < 60) {
                newCon.addError('You already updated the contact within 1 hour. Please try again after 1 hour.');
            }
        }
    }
}

Scenario 2 :Prevent Duplicate Contact Emails Within the Same Account ?

Trigger ContactDuplicateEmailCheck on Contact (Before insert, Before Update) {
 Set<Id> accId=New Set<Id>();
    for(Contact con:Trigger.New){
        if(con.AccountId !=null && con.Email !=null){
            accId.add(con.AccountId);
        }
    }
    List<Contact> conlist=[Select Id,AccountId,Email From Contact Where AccountId IN:accId AND Email !=''];
    List<Contact> existingcon=New List<Contact>();
    for(Contact con:conlist){
     existingcon.add(con);
    }
    for(Contact con:Trigger.New){
        if(existingcon.size()>0){
            con.Adderror('A contact Email already exists under the same Account');
        }
    }
 }

Scenario 3: Update Account’s Contact Count After Contact Insert ?

Trigger HelloWorldTrigger on Contact (Before Insert,After Insert) {
 //Contacttrigger.Contactmethod(Trigger.New);
 if(Trigger.Isafter){
  Set<Id> AccId=New Set<Id>();
  List<Account> ACClist=New List<Account>();
  for(Contact Con: Trigger.New){
   If(Con.AccountId!=Null){
   AccId.add(Con.AccountId);
   }
  }
  List<Account> ACC=[Select Id,No_Of_Contacts__c,(Select Id From Contacts) From Account];
  for(Account Ac:ACC){
  if(Ac.Contacts.Size()>0){
      Ac.No_Of_Contacts__c=Ac.Contacts.Size();
      ACClist.add(Ac);
  }
  }
  if(ACClist.Size()>0){
   Update ACClist;
  }
 }
}

Scenario 4: Contact Trigger with Handler Class for Insert Validation, Delete Restriction, and Sharing Automation

Trigger ContactTrigger on Contact (Before insert,Before delete,after insert) {
   if(Trigger.isBefore && Trigger.isInsert){ 
       ContactTriggerhandler.handlebewforeinsert(Trigger.New);
   } 
    if(Trigger.isBefore && Trigger.isDelete){
        ContactTriggerhandler.handlebeforedeleteactivities(Trigger.oldMap);
    }
    if(Trigger.isInsert && Trigger.isAfter){
        ContactTriggerhandler.handleafterinsertactivities(Trigger.New);
    }
}

ContactTriggerhandler Class

public class ContactTriggerhandler {

    Public Static void handlebeforedeleteactivities(Map<Id,Contact> oldRecords){
        for(Contact Clist:[Select Id From Contact Where  ID IN (Select ContactId From Opportunity) AND ID IN :oldRecords.keySet()]){
            oldRecords.get(Clist.Id).addError('Not authorise to delete id contact having Opportunity');    
        }
    }
    public static void handlebewforeinsert(List<Contact> Listrecords){
        for(Contact Conlist:Listrecords){
            if(Conlist.AccountId ==Null){
                Conlist.AccountId.addError('Account is required to create a contact');
            }
        }
    }
    public static void handleafterinsertactivities(List<Contact> contactrecords){
        List<ContactShare> cslist=New List<ContactShare>();
        Id ContactInnoveters = [Select Id From Group Where Name='Contact Innoveters'].Id;
        for(Contact con: contactrecords){
            ContactShare cs=new ContactShare();
            cs.ContactId=con.Id;
            cs.ContactAccessLevel='Edit';
            cs.RowCause='Manual';
            cs.UserOrGroupId=ContactInnoveters;
            cslist.add(cs);
        }
        if(!cslist.isEmpty()){
            insert cslist;
        }
    }
}

 Scenario 5 : Prevent Deletion of Accounts with 'Hot' Rating

trigger AccDeletion on Account (before delete) {
    //AccountTriggerHandler.preventDeletion(Trigger.old);
   List<Account> accountsToPreventDeletion = new List<Account>();
        
        for (Account acc : Trigger.Old) {
            if (acc.Rating == 'Hot') {
                accountsToPreventDeletion.add(acc);
            }
        }
        
        if (!accountsToPreventDeletion.isEmpty()) {
            for (Account acc : accountsToPreventDeletion) {
                acc.addError('You cannot delete an this account!');
            }
        }
}

 Scenario 6 : Prevent Deletion of Accounts with Related Opportunities

trigger AccountDeletion on Account (Before delete) {
    // Prevent the deletion of accounts if they have related opportunities.
    for(Account a:[Select Id,Name From Account Where ID IN (Select AccountId From Opportunity) AND ID IN : Trigger.Old]){
        Trigger.OldMap.get(a.Id).Adderror('Cannot delete account with related opportunities');
    }
}

 Scenario 7 : Prevent Duplicate Account Name on Insert and Update

trigger DuplicateName on Account (Before Insert, Before Update) {
 List<String> acc=new List<String>();
 for(Account ac : Trigger.New){
    Account a=new Account();
    acc.Add(ac.Name);
 }
 List<Account> acclist=[Select Id, Name from Account Where Name IN: acc];
   for(Account ac : Trigger.New){
     if(acclist.size()>=1){
         ac.adderror('Dont Insert or Update Duplicate Account Name');
  }
 } 
}

Scenario 8 : Update Account with Total Opportunity Count After Opportunity Insert

Trigger CountOppTrig on Opportunity (After Insert) {
 Set<Id> AcId=New Set<Id>();
 List<Account> AccId=new List<Account>();
    for(Opportunity Opp: Trigger.New){
        if(Opp.AccountId!=Null){
          AcId.add(Opp.AccountId);
        }
    }
    List<Account> ACC=[Select Id,Name,Number_of_Opp__c,(Select Id From Opportunities) From Account Where Id IN :AcId];
    for(Account Aclist:ACC){
        if(Aclist.Opportunities.size()>0){
          Aclist.Number_of_Opp__c=Aclist.Opportunities.size();
          AccId.add(Aclist);
        }
    }
    if(AccId.size()>0){
      Update AccId;
    }
}

Scenario 9 : Auto-Create Follow-Up Tasks for Contacts When Opportunity Is Closed Won ?

Trigger CloseWon on Opportunity (After update) {
    if(Trigger.isAfter && Trigger.isUpdate){
        oppCloseWon.afterupdatetrigger(Trigger.new, Trigger.oldMap);
    }
}

OppCloseWon Class :

Public Class oppCloseWon {
    Public Static Void afterupdatetrigger(List<Opportunity> opplist, Map<id,Opportunity> oppMap){
        Set<id> oppId=New Set<id>();
        for(Opportunity opp:opplist){
            if(opp.StageName == 'Closed Won' && opp.StageName!=oppMap.get(opp.Id).StageName){
                oppId.add(opp.AccountId);
            }
        }
        List<Contact> acclist= [Select Id From Contact Where AccountId in:oppId];
        List<Task> tasklist=new List<Task>();
        for(Contact clist:acclist){
            Task t = new Task();
        t.Subject = 'Follow up';
         t.WhoId = clist.Id; 
            tasklist.add(t);
        }
       if (!tasklist.isEmpty()) {
           insert tasklist;
          }
    }
}

Scenario 10 : Comprehensive Opportunity Trigger with Team Member Management, Task Creation, and Stage-Based Automation ?

Trigger Opportunitytrigger on Opportunity (After Update,After Insert,Before Update) {
 
    if(Trigger.isUpdate){
        OpportunityTriggerHandler.Handleactivitiesafterupdate(Trigger.NEW);
        OpportunityTriggerHandler.addteammembers(Trigger.New, Trigger.OldMap);
    }
    if(Trigger.isInsert && Trigger.isAfter){
        OpportunityTriggerHandler.Handleactivitiesafterinsert(Trigger.NEW);
    }
    if(Trigger.isUpdate && Trigger.isBefore){
        OpportunityTriggerHandler.HandleactivitiesBeforeupdate(Trigger.NEW,Trigger.OldMap);
    }
}

OpportunityTriggerHandler Class :

Public class OpportunityTriggerHandler {
    
    Public Static Void HandleactivitiesBeforeupdate(List<Opportunity> newRecords,Map<Id,Opportunity> OldRecords){
        /*for(Opportunity newlist:newRecords){
            if(OldRecords.get(newlist.Id).StageName !=newlist.StageName){
                     newlist.Amount=newlist.Probability*newlist.ExpectedRevenue;
            }
        }*/
    }
    Public Static void addteammembers(List<Opportunity> newRecords,Map<Id,Opportunity> OldRecords){
        List<OpportunityTeamMember> Oppteamlist=New List<OpportunityTeamMember>();
        List<User> userlist= [Select Id,UserRole.DeveloperName From User Where IsActive = true  AND UserRole.DeveloperName = 'Opp_Record_Access'];
        for(Opportunity Oplist:newRecords){
               if(Oplist.StageName=='Needs Analysis' && Oplist.StageName != OldRecords.get(Oplist.Id).StageName){
                for(User Userl:userlist){
                OpportunityTeamMember OpTM=New OpportunityTeamMember();
                OpTM.OpportunityId=Oplist.Id;
                OpTM.OpportunityAccessLevel='Edit';
                OpTM.UserId=Userl.Id;
                Oppteamlist.add(OpTM);
               }
            }
        }
        if(!Oppteamlist.isEmpty()){
            Insert Oppteamlist;
        }
    }
 Public Static Void Handleactivitiesafterinsert(List<Opportunity> Opplist){
        List<Task> tasklist=new List<Task>();
        for(Opportunity opprecord:Opplist){
                Task taskrecord=new Task();
                taskrecord.Priority='High';
                taskrecord.OwnerId=opprecord.OwnerId;
                taskrecord.Description='Follow with new task';
                taskrecord.Status='Not Started';
                taskrecord.Subject='New Record Is created';
                taskrecord.WhatId=opprecord.Id;
                taskrecord.ActivityDate=System.today();
                tasklist.add(taskrecord);
        }
        if(!tasklist.isEmpty()){
            Insert tasklist;
        }
    }
    Public Static Void Handleactivitiesafterupdate(List<Opportunity> Opplist){
        List<Task> tasklist=new List<Task>();
        List<Id> OpId=new List<Id>();
        List<OpportunityTeamMember> OpTeammemebr=new List<OpportunityTeamMember>();
        for(Opportunity Opplists: Opplist){
            OpId.add(Opplists.Id);
        }
        List<OpportunityTeamMember> OpTeamList=[Select Id,OpportunityId From OpportunityTeamMember Where OpportunityId IN :OpId];
        for(Opportunity opprecord:Opplist){
            if(opprecord.StageName=='Closed Won'){
                Task taskrecord=new Task();
                taskrecord.Priority='High';
                taskrecord.OwnerId=opprecord.OwnerId;
                taskrecord.Description='Please split the revenue among the team members';
                taskrecord.Status='Not Started';
                taskrecord.Subject='Split Revenue';
                taskrecord.WhatId=opprecord.Id;
                taskrecord.ActivityDate=System.today();
                tasklist.add(taskrecord);
            }
            else if(opprecord.StageName=='Closed Lost'){
               for(OpportunityTeamMember Opteammemlist:OpTeamList){
                   if(Opteammemlist.OpportunityId ==opprecord.Id){
                       OpTeammemebr.add(Opteammemlist);
                   }
                }
            }
        }
        if(tasklist.Size()>0){
            Insert tasklist;
        }
        if(!OpTeammemebr.isEmpty()){
            Delete OpTeammemebr;
        }
    }
}

Scenario 11 : Every time an account website is updated, update the website field on all its child contacts ?

Trigger Preventaccountupdate on Account (Before Update,After Update) {
    if(Trigger.isUpdate && Trigger.isBefore){
       PreventaccountupdateClass.preventupdate(Trigger.new,Trigger.oldmap);
    }
    if(Trigger.isUpdate && Trigger.isAfter){
       PreventaccountupdateClass.updatechidrec(Trigger.new,Trigger.oldmap);
    }
}

Public Class PreventaccountupdateClass {
    Public static void updatechidrec(List<Account> newRec,Map<Id,Account> oldsetrec){
       Map<Id,String> AccMap=New Map<Id,String>();
        for(Account ac:newRec){
            if(ac.Website != oldsetrec.get(ac.Id).Website){
                AccMap.put(ac.Id,ac.Website);
            }
        }
        List<Contact> conlist=[Select Id,Website__c,AccountId From Contact Where AccountId IN :AccMap.keyset()];
        List<Contact> clist=New List<Contact>();
        for(Contact c:conlist){
            c.Website__c = AccMap.get(c.AccountId);
            clist.add(c);
        }
        if(clist.size()>0){
            update clist;
        }
    }    
    
    Public static void preventupdate(List<Account> acclist,Map<Id,Account> OldrecordMap){
        for(Account ac:acclist){
            if(ac.LastModifiedById == Userinfo.getuserId()){
                Long timediff=Datetime.Now().getTime()-ac.LastModifiedDate.getTime();
                timediff = timediff/(60*1000);
                if(timediff<60){
                    ac.addError('You can not update lessthan 1 Hour Elapsed Time');
                }
            }
        }
        for(Account acrec:acclist){
            if(acrec.Industry == 'Banking'){
                if(acrec.Ownership != OldrecordMap.get(acrec.Id).Ownership && acrec.Ownership =='Private'){
                    acrec.Adderror('Dont allow user to update ownership');
                }
            }
        }
    }
}

Scenario 12 : Opportunity Closed-Won , Delete the Opportunity Team members ?

Trigger oppTrigger on Opportunity (After Delete,After Update) {
    if(Trigger.isDelete && Trigger.isAfter){
        oppTrigger_Helper.afterDelete(Trigger.Old);
    }
    if(Trigger.isupdate && Trigger.isAfter){
        oppTrigger_Helper.afterupdate_Delete(Trigger.new);
    }
}

Public Class oppTrigger_Helper {
    
    Public static void afterupdate_Delete(List<Opportunity> Opprec){
        Set<Id> Opid=new Set<Id>();
        for(Opportunity op:Opprec){
            if(op.StageName == 'Closed Lost'){
               Opid.add(op.Id);
            }  
        }
        List<Opportunityteammember> OpTeam = [SELECT Id,Opportunity.Id FROM Opportunityteammember Where Opportunity.Id IN : Opid];
        if(OpTeam.size()>0){
            delete OpTeam;
        }
    }
    
    
    Public static void afterDelete(List<Opportunity> Opprec){
    Set<Id> accId = New Set<Id>();
    Map<Id,Id> OppIdMap=New Map<Id,Id>();
    Map<Id,Id> AccOwnerId=New Map<Id,Id>();
        for(Opportunity op:Opprec){
               accId.add(op.AccountId);
               OppIdMap.put(op.Id,op.AccountId);
        }
        for(Account aclist:[Select Id,OwnerId From Account Where Id IN :accId]){
            AccOwnerId.put(aclist.Id,aclist.OwnerId);
        }
        List<Task> Ts=New List<Task>();
        for(Opportunity op:Opprec){
            Task t=New Task();
            t.Status = 'Not Started';
            t.Priority = 'High';
            t.OwnerId = AccOwnerId.get(OppIdMap.get(op.Id));
            t.Subject = 'Follow up Task';
            Ts.add(t);
        }
        if(Ts.size()>0){
            insert Ts;
        }
    }
}

Scenario 13 : Trigger that prevents duplicate Contact creation under the same Account ?

Trigger PreventDuplicateContact on Contact (Before Insert,Before Update) {
  Set<Id> Accid=New Set<Id>();
    for(Contact con:Trigger.New){
        if(con.AccountId !=null){
            Accid.add(con.AccountId);
        }
    }
    List<Contact> conlist=[Select Id,FirstName,LastName,AccountId From Contact Where AccountId IN : Accid];
    List<String> keyString=New List<String>();
    for(Contact conli:conlist){
        String conString=conli.AccountId+'-'+conli.FirstName.toLowerCase().trim()+'-'+conli.LastName.toLowerCase().trim();
        keyString.add(conString);
    }
    for(Contact conl:Trigger.New){
    if(conl.AccountId != null && conl.LastName != null && conl.FirstName != null){
       String conString=conl.AccountId+'-'+conl.FirstName.toLowerCase().trim()+'-'+conl.LastName.toLowerCase().trim();
        if(keyString.Contains(conString)){
            conl.Adderror('A contact with the same First Name and Last Name already exists under this Account.');
        }
      }
    }
}