Getting Started with Salesforce Apex

/**
 * Batch APEX Class with Chaining Pattern
 * Process large Account datasets with dependent operations
 */
global class AccountRevenueBatch implements Database.Batchable<SObject>, Database.Stateful {
    
    // Stateful variables for chaining
    global Map<Id, Decimal> accountRevenueMap;
    global Integer totalProcessed = 0;
    global Integer batchSequence = 1;
    
    global AccountRevenueBatch() {
        this.accountRevenueMap = new Map<Id, Decimal>();
    }
    
    // Start method - Query all active Accounts with Opportunities
    global Database.QueryLocator start(Database.BatchableContext bc) {
        String query = 'SELECT Id, Name, AnnualRevenue, ' +
                      '(SELECT Amount, CloseDate FROM Opportunities WHERE StageName = \'Closed Won\' ) ' +
                      'FROM Account WHERE Active__c = true';
        return Database.getQueryLocator(query);
    }
    
    // Execute method - Process each batch of records
    global void execute(Database.BatchableContext bc, List<Account> scope) {
        List<Account> accountsToUpdate = new List<Account>();
        
        for (Account acc : scope) {
            Decimal totalWonAmount = 0;
            
            // Calculate total won opportunity amount
            if (acc.Opportunities != null) {
                for (Opportunity opp : acc.Opportunities) {
                    if (opp.Amount != null) {
                        totalWonAmount += opp.Amount;
                    }
                }
            }
            
            // Update Account revenue
            if (totalWonAmount > 0 && acc.AnnualRevenue != totalWonAmount) {
                acc.AnnualRevenue = totalWonAmount;
                accountsToUpdate.add(acc);
                accountRevenueMap.put(acc.Id, totalWonAmount);
            }
            
            totalProcessed++;
        }
        
        // Perform DML operation with error handling
        if (!accountsToUpdate.isEmpty()) {
            Database.SaveResult[] results = Database.update(accountsToUpdate, false);
            logErrors(results, accountsToUpdate);
        }
    }
    
    // Finish method - Chain to next batch or send notification
    global void finish(Database.BatchableContext bc) {
        System.debug('Batch ' + batchSequence + ' completed. Processed ' + totalProcessed + ' records.');
        
        // Chain to Contact update batch if needed
        if (batchSequence < 3) {
            batchSequence++;
            Database.executeBatch(new ContactSyncBatch(accountRevenueMap), 100);
        } else {
            // Send completion notification
            sendCompletionEmail();
        }
    }
    
    // Helper method for error logging
    private void logErrors(Database.SaveResult[] results, List<Account> accounts) {
        for (Integer i = 0; i < results.size(); i++) {
            if (!results[i].isSuccess()) {
                System.debug('Error updating Account ' + accounts[i].Id + ': ' + results[i].getErrors());
            }
        }
    }
    
    private void sendCompletionEmail() {
        // Implementation for sending completion email
        Messaging.SingleEmailMessage mail = new Messaging.SingleEmailMessage();
        mail.setSubject('Batch Processing Complete');
        mail.setPlainTextBody('Processed ' + totalProcessed + ' accounts successfully.');
        Messaging.sendEmail(new Messaging.SingleEmailMessage[]{mail});
    }
}

/**
 * Trigger Handler Base Class
 * Provides reusable trigger pattern implementation
 */
public abstract class TriggerHandler {
    
    // Context variables
    protected Boolean isExecuting = false;
    protected List<SObject> newList;
    protected List<SObject> oldList;
    protected Map<Id, SObject> newMap;
    protected Map<Id, SObject> oldMap;
    protected TriggerOperation operationType;
    
    // Constructor
    public TriggerHandler() {
        this.isExecuting = Trigger.isExecuting;
        this.newList = Trigger.new;
        this.oldList = Trigger.old;
        this.newMap = Trigger.newMap;
        this.oldMap = Trigger.oldMap;
        this.operationType = Trigger.operationType;
    }
    
    // Main execution method
    public void run() {
        // Check if already executed in this context
        if (checkRecursive()) return;
        
        // Execute based on operation type
        switch on operationType {
            when BEFORE_INSERT {
                beforeInsert();
            }
            when AFTER_INSERT {
                afterInsert();
            }
            when BEFORE_UPDATE {
                beforeUpdate();
            }
            when AFTER_UPDATE {
                afterUpdate();
            }
            when BEFORE_DELETE {
                beforeDelete();
            }
            when AFTER_DELETE {
                afterDelete();
            }
            when AFTER_UNDELETE {
                afterUndelete();
            }
        }
    }
    
    // Abstract methods to be implemented by concrete handlers
    protected virtual void beforeInsert() {}
    protected virtual void afterInsert() {}
    protected virtual void beforeUpdate() {}
    protected virtual void afterUpdate() {}
    protected virtual void beforeDelete() {}
    protected virtual void afterDelete() {}
    protected virtual void afterUndelete() {}
    
    // Recursion prevention
    private Boolean checkRecursive() {
        // Implement recursion checking logic
        String handlerName = String.valueOf(this).split(':')[0];
        if (TriggerHandler.recursiveHandlers == null) {
            TriggerHandler.recursiveHandlers = new Set<String>();
        }
        
        if (TriggerHandler.recursiveHandlers.contains(handlerName)) {
            return true;
        }
        
        TriggerHandler.recursiveHandlers.add(handlerName);
        return false;
    }
    
    // Static recursion prevention set
    private static Set<String> recursiveHandlers;
    
    // Utility methods
    protected Boolean isChanged(SObject newObj, SObject oldObj, String fieldName) {
        return newObj.get(fieldName) != oldObj.get(fieldName);
    }
    
    protected Boolean isInsert() { return operationType == TriggerOperation.BEFORE_INSERT || 
        operationType == TriggerOperation.AFTER_INSERT; }
    
    protected Boolean isUpdate() { return operationType == TriggerOperation.BEFORE_UPDATE || 
        operationType == TriggerOperation.AFTER_UPDATE; }
    
    protected Boolean isDelete() { return operationType == TriggerOperation.BEFORE_DELETE || 
        operationType == TriggerOperation.AFTER_DELETE; }
}

/**
 * Concrete Account Trigger Handler
 */
public class AccountTriggerHandler extends TriggerHandler {
    
    // Custom settings for business logic
    private static final String ENTERPRISE_TIER = 'Enterprise';
    private static final Decimal REVENUE_THRESHOLD = 1000000;
    
    @Override
    protected void beforeInsert() {
        validateAccounts();
        setAccountTier();
        generateAccountNumber();
    }
    
    @Override
    protected void afterInsert() {
        createDefaultOpportunities();
        notifySalesTeam();
        logAccountCreation();
    }
    
    @Override
    protected void beforeUpdate() {
        validateAccountUpdates();
        trackRevenueChanges();
        enforceValidationRules();
    }
    
    @Override
    protected void afterUpdate() {
        syncRelatedRecords();
        updateFinancialRollups();
        sendUpdateNotifications();
    }
    
    // Implementation methods
    private void validateAccounts() {
        for (Account acc : (List<Account>)newList) {
            if (String.isBlank(acc.Name)) {
                acc.Name.addError('Account name is required');
            }
            
            if (acc.AnnualRevenue != null && acc.AnnualRevenue < 0) {
                acc.AnnualRevenue.addError('Annual Revenue cannot be negative');
            }
        }
    }
    
    private void setAccountTier() {
        for (Account acc : (List<Account>)newList) {
            if (acc.AnnualRevenue != null && acc.AnnualRevenue >= REVENUE_THRESHOLD) {
                acc.Tier__c = ENTERPRISE_TIER;
            } else if (acc.NumberOfEmployees != null && acc.NumberOfEmployees > 500) {
                acc.Tier__c = 'Large Business';
            } else {
                acc.Tier__c = 'Small Business';
            }
        }
    }
    
    private void generateAccountNumber() {
        Integer sequenceNumber = [SELECT COUNT() FROM Account] + 1;
        for (Account acc : (List<Account>)newList) {
            if (acc.AccountNumber == null) {
                acc.AccountNumber = 'ACC-' + DateTime.now().format('YYYYMM') + 
                    '-' + String.valueOf(sequenceNumber).leftPad(6, '0');
                sequenceNumber++;
            }
        }
    }
    
    private void trackRevenueChanges() {
        Map<Id, Account> oldAccountMap = (Map<Id, Account>)oldMap;
        
        for (Account newAcc : (List<Account>)newList) {
            Account oldAcc = oldAccountMap.get(newAcc.Id);
            
            if (oldAcc != null && isChanged(newAcc, oldAcc, 'AnnualRevenue')) {
                Decimal oldValue = (Decimal)oldAcc.get('AnnualRevenue');
                Decimal newValue = (Decimal)newAcc.get('AnnualRevenue');
                
                if (newValue != null && oldValue != null) {
                    Decimal changePercentage = ((newValue - oldValue) / oldValue) * 100;
                    
                    if (Math.abs(changePercentage) > 50) {
                        // Log significant revenue change
                        System.debug('Significant revenue change for Account ' + 
                            newAcc.Id + ': ' + changePercentage + '%');
                    }
                }
            }
        }
    }
}

/**
 * Service Interface for Dependency Injection
 */
public interface IAccountService {
    Account createAccount(AccountDTO accountData);
    Account updateAccount(Id accountId, AccountDTO updates);
    void deleteAccount(Id accountId);
    List<Account> getAccountsByCriteria(Map<String, Object> criteria);
    Decimal calculateTotalRevenue(Id accountId);
}

/**
 * DTO (Data Transfer Object) for Account operations
 */
public class AccountDTO {
    public String name { get; set; }
    public String industry { get; set; }
    public Decimal annualRevenue { get; set; }
    public Integer numberOfEmployees { get; set; }
    public String billingCity { get; set; }
    public String billingState { get; set; }
    public String tier { get; set; }
    
    // Validation method
    public Boolean isValid() {
        return String.isNotBlank(name) && 
               String.isNotBlank(industry) && 
               annualRevenue != null && 
               annualRevenue >= 0;
    }
}

/**
 * Concrete Account Service Implementation
 */
public class AccountServiceImpl implements IAccountService {
    
    // Dependency injection for data access
    private IAccountDAO accountDAO;
    private IOpportunityService opportunityService;
    
    // Constructor with dependency injection
    public AccountServiceImpl() {
        this.accountDAO = new AccountDAOImpl();
        this.opportunityService = new OpportunityServiceImpl();
    }
    
    // Constructor for testing (dependency injection)
    public AccountServiceImpl(IAccountDAO accountDAO, IOpportunityService oppService) {
        this.accountDAO = accountDAO;
        this.opportunityService = oppService;
    }
    
    public Account createAccount(AccountDTO accountData) {
        // Validate input
        if (!accountData.isValid()) {
            throw new AccountServiceException('Invalid account data provided');
        }
        
        // Convert DTO to SObject
        Account newAccount = new Account(
            Name = accountData.name,
            Industry = accountData.industry,
            AnnualRevenue = accountData.annualRevenue,
            NumberOfEmployees = accountData.numberOfEmployees,
            BillingCity = accountData.billingCity,
            BillingState = accountData.billingState,
            Tier__c = accountData.tier
        );
        
        try {
            // Insert account
            accountDAO.insertAccount(newAccount);
            
            // Create default opportunity
            if (accountData.annualRevenue > 100000) {
                opportunityService.createDefaultOpportunity(newAccount.Id);
            }
            
            // Log creation
            System.debug('Account created: ' + newAccount.Id);
            
            return newAccount;
            
        } catch (DmlException e) {
            throw new AccountServiceException('Failed to create account: ' + e.getMessage());
        }
    }
    
    public Account updateAccount(Id accountId, AccountDTO updates) {
        // Retrieve existing account
        Account existingAccount = accountDAO.getAccountById(accountId);
        
        if (existingAccount == null) {
            throw new AccountServiceException('Account not found: ' + accountId);
        }
        
        // Apply updates
        if (updates.name != null) existingAccount.Name = updates.name;
        if (updates.industry != null) existingAccount.Industry = updates.industry;
        if (updates.annualRevenue != null) existingAccount.AnnualRevenue = updates.annualRevenue;
        if (updates.numberOfEmployees != null) existingAccount.NumberOfEmployees = updates.numberOfEmployees;
        if (updates.tier != null) existingAccount.Tier__c = updates.tier;
        
        try {
            // Update account
            accountDAO.updateAccount(existingAccount);
            
            // Update related records if revenue changed significantly
            if (updates.annualRevenue != null && 
                Math.abs(updates.annualRevenue - existingAccount.AnnualRevenue) > 10000) {
                opportunityService.updateOpportunityForecasts(accountId);
            }
            
            return existingAccount;
            
        } catch (DmlException e) {
            throw new AccountServiceException('Failed to update account: ' + e.getMessage());
        }
    }
    
    public void deleteAccount(Id accountId) {
        // Check for related opportunities
        Integer opportunityCount = opportunityService.getOpportunityCount(accountId);
        
        if (opportunityCount > 0) {
            throw new AccountServiceException(
                'Cannot delete account with ' + opportunityCount + ' related opportunities'
            );
        }
        
        try {
            accountDAO.deleteAccount(accountId);
            System.debug('Account deleted: ' + accountId);
        } catch (DmlException e) {
            throw new AccountServiceException('Failed to delete account: ' + e.getMessage());
        }
    }
    
    public List<Account> getAccountsByCriteria(Map<String, Object> criteria) {
        return accountDAO.getAccountsByCriteria(criteria);
    }
    
    public Decimal calculateTotalRevenue(Id accountId) {
        List<Opportunity> opportunities = opportunityService.getWonOpportunities(accountId);
        Decimal totalRevenue = 0;
        
        for (Opportunity opp : opportunities) {
            if (opp.Amount != null) {
                totalRevenue += opp.Amount;
            }
        }
        
        return totalRevenue;
    }
}

/**
 * Custom Exception for Account Service
 */
public class AccountServiceException extends Exception {}

/**
 * Data Access Interface
 */
public interface IAccountDAO {
    Account getAccountById(Id accountId);
    List<Account> getAccountsByCriteria(Map<String, Object> criteria);
    void insertAccount(Account account);
    void updateAccount(Account account);
    void deleteAccount(Id accountId);
}

/**
 * Concrete DAO Implementation
 */
public class AccountDAOImpl implements IAccountDAO {
    
    public Account getAccountById(Id accountId) {
        try {
            return [SELECT Id, Name, Industry, AnnualRevenue, NumberOfEmployees, 
                    BillingCity, BillingState, Tier__c, CreatedDate
                   FROM Account 
                   WHERE Id = :accountId 
                   LIMIT 1];
        } catch (QueryException e) {
            throw new AccountServiceException('Error retrieving account: ' + e.getMessage());
        }
    }
    
    public List<Account> getAccountsByCriteria(Map<String, Object> criteria) {
        String query = 'SELECT Id, Name, Industry, AnnualRevenue FROM Account WHERE ';
        List<String> conditions = new List<String>();
        List<Object> parameters = new List<Object>();
        
        // Build dynamic query based on criteria
        if (criteria.containsKey('industry')) {
            conditions.add('Industry = :param' + parameters.size());
            parameters.add(criteria.get('industry'));
        }
        
        if (criteria.containsKey('minRevenue')) {
            conditions.add('AnnualRevenue >= :param' + parameters.size());
            parameters.add(criteria.get('minRevenue'));
        }
        
        if (criteria.containsKey('maxRevenue')) {
            conditions.add('AnnualRevenue <= :param' + parameters.size());
            parameters.add(criteria.get('maxRevenue'));
        }
        
        if (criteria.containsKey('tier')) {
            conditions.add('Tier__c = :param' + parameters.size());
            parameters.add(criteria.get('tier'));
        }
        
        if (conditions.isEmpty()) {
            conditions.add('Id != null'); // Default condition
        }
        
        query += String.join(conditions, ' AND ');
        query += ' ORDER BY AnnualRevenue DESC NULLS LAST LIMIT 1000';
        
        return Database.queryWithBinds(query, parameters, AccessLevel.USER_MODE);
    }
    
    public void insertAccount(Account account) {
        insert account;
    }
    
    public void updateAccount(Account account) {
        update account;
    }
    
    public void deleteAccount(Id accountId) {
        delete new Account(Id = accountId);
    }
}

/**
 * Test Class for Account Service
 * Demonstrates proper testing patterns and best practices
 */
@isTest
private class AccountServiceTest {
    
    @testSetup
    static void setupTestData() {
        // Create test accounts
        List<Account> testAccounts = new List<Account>();
        
        for (Integer i = 0; i < 5; i++) {
            testAccounts.add(new Account(
                Name = 'Test Account ' + i,
                Industry = 'Technology',
                AnnualRevenue = 100000 * (i + 1),
                NumberOfEmployees = 50 * (i + 1)
            ));
        }
        
        insert testAccounts;
        
        // Create test opportunities for some accounts
        List<Opportunity> testOpportunities = new List<Opportunity>();
        for (Account acc : [SELECT Id FROM Account LIMIT 3]) {
            testOpportunities.add(new Opportunity(
                Name = 'Test Opp for ' + acc.Name,
                AccountId = acc.Id,
                StageName = 'Closed Won',
                CloseDate = Date.today().addDays(30),
                Amount = 50000
            ));
        }
        
        insert testOpportunities;
    }
    
    @isTest
    static void testCreateAccount_Success() {
        // Create mock dependencies
        Test.setMock(HttpCalloutMock.class, new MockHttpResponseGenerator());
        
        // Create test DTO
        AccountDTO accountData = new AccountDTO();
        accountData.name = 'New Test Account';
        accountData.industry = 'Healthcare';
        accountData.annualRevenue = 500000;
        accountData.numberOfEmployees = 100;
        accountData.tier = 'Enterprise';
        
        // Create service instance
        IAccountService accountService = new AccountServiceImpl();
        
        Test.startTest();
        Account createdAccount = accountService.createAccount(accountData);
        Test.stopTest();
        
        // Verify results
        System.assertNotEquals(null, createdAccount.Id, 'Account should have been created');
        System.assertEquals('New Test Account', createdAccount.Name);
        System.assertEquals('Healthcare', createdAccount.Industry);
        System.assertEquals(500000, createdAccount.AnnualRevenue);
        
        // Verify related records were created
        List<Opportunity> relatedOpps = [SELECT Id FROM Opportunity WHERE AccountId = :createdAccount.Id];
        System.assertEquals(1, relatedOpps.size(), 'Default opportunity should have been created');
    }
    
    @isTest
    static void testCreateAccount_ValidationFailure() {
        // Create invalid DTO
        AccountDTO invalidData = new AccountDTO();
        invalidData.name = ''; // Empty name
        invalidData.annualRevenue = -1000; // Negative revenue
        
        IAccountService accountService = new AccountServiceImpl();
        
        Test.startTest();
        try {
            Account result = accountService.createAccount(invalidData);
            System.assert(false, 'Should have thrown exception for invalid data');
        } catch (AccountServiceException e) {
            // Expected exception
            System.assert(e.getMessage().contains('Invalid account data'), 
                'Should throw validation exception');
        }
        Test.stopTest();
    }
    
    @isTest
    static void testUpdateAccount_Success() {
        // Get existing test account
        Account existingAccount = [SELECT Id, Name, AnnualRevenue FROM Account LIMIT 1];
        
        // Create update DTO
        AccountDTO updates = new AccountDTO();
        updates.name = 'Updated Account Name';
        updates.annualRevenue = existingAccount.AnnualRevenue + 100000;
        
        IAccountService accountService = new AccountServiceImpl();
        
        Test.startTest();
        Account updatedAccount = accountService.updateAccount(existingAccount.Id, updates);
        Test.stopTest();
        
        // Verify updates
        System.assertEquals('Updated Account Name', updatedAccount.Name);
        System.assertEquals(existingAccount.AnnualRevenue + 100000, updatedAccount.AnnualRevenue);
    }
    
    @isTest
    static void testCalculateTotalRevenue() {
        // Get account with opportunities
        Account testAccount = [SELECT Id FROM Account WHERE Id IN (
            SELECT AccountId FROM Opportunity
        ) LIMIT 1];
        
        IAccountService accountService = new AccountServiceImpl();
        
        Test.startTest();
        Decimal totalRevenue = accountService.calculateTotalRevenue(testAccount.Id);
        Test.stopTest();
        
        // Verify calculation
        System.assertEquals(50000, totalRevenue, 'Should calculate total from won opportunities');
    }
    
    @isTest
    static void testBatchAPEX_AccountProcessing() {
        // Insert large dataset for batch testing
        List<Account> batchAccounts = new List<Account>();
        for (Integer i = 0; i < 205; i++) {
            batchAccounts.add(new Account(
                Name = 'Batch Account ' + i,
                Industry = 'Batch Test',
                AnnualRevenue = 10000,
                Active__c = true
            ));
        }
        insert batchAccounts;
        
        Test.startTest();
        AccountRevenueBatch batchJob = new AccountRevenueBatch();
        Database.executeBatch(batchJob, 200);
        Test.stopTest();
        
        // Verify batch processing
        List<Account> processedAccounts = [SELECT Id, AnnualRevenue FROM Account WHERE Industry = 'Batch Test'];
        System.assertEquals(205, processedAccounts.size(), 'All batch accounts should be processed');
    }
    
    @isTest
    static void testTriggerHandler_AccountInsert() {
        // Test data for trigger
        Account testAccount = new Account(
            Name = 'Trigger Test Account',
            Industry = 'Finance',
            AnnualRevenue = 750000,
            NumberOfEmployees = 200
        );
        
        Test.startTest();
        insert testAccount;
        Test.stopTest();
        
        // Verify trigger effects
        Account insertedAccount = [SELECT Id, Tier__c, AccountNumber FROM Account WHERE Id = :testAccount.Id];
        System.assertNotEquals(null, insertedAccount.Tier__c, 'Tier should be set by trigger');
        System.assert(insertedAccount.AccountNumber.startsWith('ACC-'), 
            'Account number should be generated');
    }
    
    // Mock HTTP response for callout testing
    private class MockHttpResponseGenerator implements HttpCalloutMock {
        public HTTPResponse respond(HTTPRequest req) {
            HttpResponse res = new HttpResponse();
            res.setHeader('Content-Type', 'application/json');
            res.setBody('{"success": true, "data": {"id": "12345"}}');
            res.setStatusCode(200);
            return res;
        }
    }
}