Best Salesforce vs Salesforce: Which Wins?

/**
 * OpportunityClosedHandler.cls
 * Sales Cloud pattern: Post-close automation for Opportunity records.
 * Handles bulk operations (up to 200 records per transaction).
 * Tested on Salesforce Enterprise Edition, API v59.0, Summer '24.
 */
public with sharing class OpportunityClosedHandler {

    // Main entry point — called from trigger on Opportunity (after update)
    public static void handleClosedOpportunities(List<Opportunity> newList, 
                                                  Map<Id, Opportunity> oldMap) {
        List<Task> tasksToInsert = new List<Task>();
        List<Account> accountsToUpdate = new List<Account>();
        Set<Id> accountIds = new Set<Id>();

        // Step 1: Filter opportunities that transitioned to Closed Won
        for (Opportunity opp : newList) {
            Opportunity oldOpp = oldMap.get(opp.Id);
            if (opp.StageName == 'Closed Won' && 
                oldOpp.StageName != 'Closed Won' &&
                opp.AccountId != null) {
                accountIds.add(opp.AccountId);
            }
        }

        if (accountIds.isEmpty()) return;

        // Step 2: Query accounts with a single SOQL (bulk-safe)
        Map<Id, Account> accountMap = new Map<Id, Account>(
            [SELECT Id, Last_Closed_Date__c, Renewal_Contact__c 
             FROM Account WHERE Id IN :accountIds]
        );

        // Step 3: Build tasks and account updates
        for (Opportunity opp : newList) {
            if (opp.StageName != 'Closed Won') continue;

            Account acc = accountMap.get(opp.AccountId);
            if (acc == null) continue;

            // Create a renewal follow-up task 90 days out
            tasksToInsert.add(new Task(
                Subject = 'Renewal Follow-Up - ' + opp.Name,
                WhatId = opp.Id,
                WhoId = opp.Contact__c,
                OwnerId = opp.OwnerId,
                ActivityDate = System.today().addDays(90),
                Priority = 'Normal',
                Status = 'Not Started',
                Description = 'Auto-generated renewal task for opportunity: ' + opp.Name
            ));

            // Update account last closed date if null or older
            if (acc.Last_Closed_Date__c == null || 
                acc.Last_Closed_Date__c < System.today()) {
                acc.Last_Closed_Date__c = System.today();
                accountsToUpdate.add(acc);
            }
        }

        // Step 4: DML with partial success handling
        if (!tasksToInsert.isEmpty()) {
            Database.SaveResult[] taskResults = Database.insert(
                tasksToInsert, false // allow partial success
            );
            List<String> taskErrors = new List<String>();
            for (Integer i = 0; i < taskResults.size(); i++) {
                if (!taskResults[i].isSuccess()) {
                    for (Database.Error err : taskResults[i].getErrors()) {
                        taskErrors.add(
                            'Task insert failed for Opp ' + 
                            tasksToInsert[i].WhatId + ': ' + 
                            err.getMessage()
                        );
                    }
                }
            }
            if (!taskErrors.isEmpty()) {
                System.debug(LoggingLevel.ERROR, 
                    'OpportunityClosedHandler Task Errors: ' + taskErrors);
            }
        }

        // Step 5: Update accounts
        if (!accountsToUpdate.isEmpty()) {
            Database.SaveResult[] acctResults = Database.update(
                accountsToUpdate, false
            );
            for (Integer i = 0; i < acctResults.size(); i++) {
                if (!acctResults[i].isSuccess()) {
                    for (Database.Error err : acctResults[i].getErrors()) {
                        System.debug(LoggingLevel.ERROR,
                            'Account update failed: ' + err.getMessage());
                    }
                }
            }
        }
    }
}

/**
 * Trigger definition (OpportunityTrigger.trigger)
 * trigger OpportunityTrigger on Opportunity (after update) {
 *     if (Trigger.isAfter && Trigger.isUpdate) {
 *         OpportunityClosedHandler.handleClosedOpportunities(
 *             Trigger.new, Trigger.oldMap);
 *     }
 * }
 */

/**
 * CaseSLAEnforcer.cls
 * Service Cloud pattern: Monitor SLA milestone breaches and escalate.
 * Uses Entitlements and EntitlementProcess (native Service Cloud features).
 * Benchmarked: API v59.0, Enterprise Edition with Service Cloud license.
 */
public with sharing class CaseSLAEnforcer {

    // Threshold for auto-escalation (minutes)
    private static final Integer ESCALATION_THRESHOLD_MIN = 15;

    /**
     * Called when a MilestoneEvent is created indicating SLA breach.
     * Processes breaches and creates escalation records.
     */
    public static void processSLABreaches(List<CaseMilestone> breachedMilestones) {
        Set<Id> caseIds = new Set<Id>();
        for (CaseMilestone cm : breachedMilestones) {
            caseIds.add(cm.CaseId);
        }

        // Query open cases with breached milestones
        List<Case> cases = [SELECT Id, CaseNumber, Priority, OwnerId, 
                             AccountId, CreatedDate, IsEscalated
                             FROM Case WHERE Id IN :caseIds 
                             AND IsClosed = false WITH SECURITY_ENFORCED];

        List<Case> casesToEscalate = new List<Case>();
        List<Escalation_Log__c> logsToInsert = new List<Escalation_Log__c>();

        for (Case c : cases) {
            // Skip already escalated cases to prevent duplicate work
            if (c.IsEscalated) continue;

            c.IsEscalated = true;
            c.Priority = calculateEscalatedPriority(c.Priority);
            casesToEscalate.add(c);

            // Create audit log entry
            logsToInsert.add(new Escalation_Log__c(
                Case__c = c.Id,
                Escalation_Reason__c = 'SLA Milestone Breach',
                Original_Priority__c = c.Priority,
                Triggered_At__c = System.now(),
                SLA_Breach_Duration_Min__c = calculateBreachDuration(c.Id)
            ));
        }

        // Perform updates with error handling
        if (!casesToEscalate.isEmpty()) {
            List<Database.SaveResult> results = Database.update(
                casesToEscalate, false);
            handleDmlErrors(results, 'Case escalation');
        }

        if (!logsToInsert.isEmpty()) {
            List<Database.SaveResult> logResults = Database.insert(
                logsToInsert, false);
            handleDmlErrors(logResults, 'Escalation log');
        }

        // Send notification to case owner's manager
        notifyManagers(casesToEscalate);
    }

    private static String calculateEscalatedPriority(String currentPriority) {
        if (currentPriority == 'Low') return 'Medium';
        if (currentPriority == 'Medium') return 'High';
        return 'Critical'; // High or already Critical
    }

    private static Decimal calculateBreachDuration(Id caseId) {
        // Query milestone events for this case to compute duration
        List<CaseMilestone>> milestones = [
            SELECT CreatedDate, CompletionDate 
            FROM CaseMilestone 
            WHERE CaseId = :caseId 
            AND IsCompleted = false 
            WITH SECURITY_ENFORCED
            ORDER BY CreatedDate DESC 
            LIMIT 1
        ];
        if (!milestones.isEmpty() && milestones[0].CreatedDate != null) {
            Long diffMs = System.now().getTime() - 
                          milestones[0].CreatedDate.getTime();
            return diffMs / 60000.0; // convert to minutes
        }
        return 0;
    }

    private static void handleDmlErrors(List<Database.SaveResult> results, 
                                         String context) {
        for (Database.SaveResult sr : results) {
            if (!sr.isSuccess()) {
                for (Database.Error err : sr.getErrors()) {
                    System.debug(LoggingLevel.ERROR,
                        context + ' error: ' + err.getMessage() +
                        ' | Fields: ' + err.getFields());
                }
            }
        }
    }

    private static void notifyManagers(List<Case> escalatedCases) {
        // Async notification to avoid mixed DML in sync context
        if (!escalatedCases.isEmpty()) {
            Set<Id> ownerIds = new Set<Id>();
            for (Case c : escalatedCases) ownerIds.add(c.OwnerId);

            // Fire platform event for async processing
            List<SLA_Escalation_Event__e> events = new List<SLA_Escalation_Event__e>();
            for (Id oid : ownerIds) {
                events.add(new SLA_Escalation_Event__e(
                    OwnerId__c = oid,
                    Message__c = 'SLA breach detected on assigned cases'
                ));
            }
            EventBus.publish(events);
        }
    }
}

/**
 * OpportunityToServiceBridge.cls
 * Bridges Sales Cloud and Service Cloud using Platform Events.
 * When an Opportunity closes above a threshold, publishes an event
 * that triggers automated service case creation for onboarding.
 * 
 * Environment: Salesforce Enterprise Edition, Summer '24, API v59.0
 * Tested with: Both Sales Cloud and Service Cloud licenses enabled
 */
public with sharing class OpportunityToServiceBridge {

    @TestVisible
    private static final Decimal HIGH_VALUE_THRESHOLD = 50000.00;

    /**
     * Called from Opportunity trigger after update.
     * Publishes platform events for high-value closed-won deals.
     */
    public static void publishServiceCreationEvents(
            List<Opportunity> newList, 
            Map<Id, Opportunity> oldMap) {

        List<High_Value_Opportunity_Event__e> events = new List<High_Value_Opportunity_Event__e>();

        for (Opportunity opp : newList) {
            Opportunity old = oldMap.get(opp.Id);

            // Only fire on Closed Won transition above threshold
            if (opp.StageName == 'Closed Won' &&
                old.StageName != 'Closed Won' &&
                opp.Amount != null &&
                opp.Amount >= HIGH_VALUE_THRESHOLD) {

                events.add(new High_Value_Opportunity_Event__e(
                    Opportunity_Id__c = opp.Id,
                    Account_Id__c = opp.AccountId,
                    Deal_Value__c = opp.Amount,
                    Owner_Id__c = opp.OwnerId,
                    Contract_Start_Date__c = System.today(),
                    Priority__c = opp.Amount > 250000 ? 'High' : 'Normal'
                ));
            }
        }

        if (!events.isEmpty()) {
            List<Database.SaveResult> results = EventBus.publish(events);
            for (Database.SaveResult sr : results) {
                if (!sr.isSuccess()) {
                    for (Database.Error err : sr.getErrors()) {
                        System.debug(LoggingLevel.ERROR,
                            'Event publish failed: ' + err.getMessage());
                    }
                }
            }
        }
    }
}

/**
 * Subscriber trigger that creates onboarding Cases in Service Cloud
 * when High_Value_Opportunity_Event__e is received.
 */
trigger ServiceCaseCreator on High_Value_Opportunity_Event__e (
    after insert) {

    List<Case>> onboardingCases = new List<Case>();

    for (High_Value_Opportunity_Event__e evt : Trigger.New) {
        onboardingCases.add(new Case(
            Subject = 'Onboarding - Opp ' + evt.Opportunity_Id__c,
            AccountId = evt.Account_Id__c,
            OwnerId = evt.Owner_Id__c,
            Origin = 'Automated',
            Type = 'Onboarding',
            Priority = evt.Priority__c,
            Contract_Start_Date__c = evt.Contract_Start_Date__c,
            Description = 'Auto-generated onboarding case for '
                        + 'high-value deal: ' + evt.Opportunity_Id__c
        ));
    }

    if (!onboardingCases.isEmpty()) {
        Database.insert(onboardingCases, false);
    }
}