Ultimate Apex Interview Questions Guide (2025): Oracle APEX & Salesforce Apex

// Advanced controller with caching and error handling
public with sharing class AdvancedAccountController {
    private static final String CACHE_PARTITION = 'AccountData';
    private static final Integer CACHE_TTL = 3600; // 1 hour
    
    // Cacheable method for wire service
    @AuraEnabled(cacheable=true)
    public static Map<String, Object> getAccountsWithMetadata(
        String searchTerm, 
        String industry, 
        Integer pageSize, 
        Integer pageNumber
    ) {
        try {
            String cacheKey = generateCacheKey('getAccounts', new List<String>{
                searchTerm, industry, String.valueOf(pageSize), String.valueOf(pageNumber)
            });
            
            // Try cache first
            Map<String, Object> cachedResult = (Map<String, Object>) 
                Cache.Org.get(CACHE_PARTITION + '.' + cacheKey);
            
            if (cachedResult != null) {
                return cachedResult;
            }
            
            // Build dynamic query
            String query = buildAccountQuery(searchTerm, industry);
            Integer offset = (pageNumber - 1) * pageSize;
            
            List<Account> accounts = Database.query(query + ' LIMIT :pageSize OFFSET :offset');
            Integer totalCount = Database.countQuery(buildCountQuery(searchTerm, industry));
            
            Map<String, Object> result = new Map<String, Object>{
                'accounts' => accounts,
                'totalCount' => totalCount,
                'pageSize' => pageSize,
                'pageNumber' => pageNumber,
                'totalPages' => Math.ceil((Decimal)totalCount / pageSize)
            };
            
            // Cache result
            Cache.Org.put(CACHE_PARTITION + '.' + cacheKey, result, CACHE_TTL);
            
            return result;
            
        } catch (Exception e) {
            throw new AuraHandledException('Error retrieving accounts: ' + e.getMessage());
        }
    }
    
    // Imperative method for data manipulation
    @AuraEnabled
    public static Map<String, Object> updateAccountWithValidation(
        Account account, 
        List<Contact> contacts
    ) {
        Savepoint sp = Database.setSavepoint();
        
        try {
            // Validate account data
            validateAccountData(account);
            
            // Update account
            update account;
            
            // Process related contacts
            Map<String, Object> contactResult = processContacts(account.Id, contacts);
            
            // Invalidate cache
            invalidateAccountCache();
            
            return new Map<String, Object>{
                'success' => true,
                'account' => account,
                'contactResult' => contactResult,
                'message' => 'Account updated successfully'
            };
            
        } catch (Exception e) {
            Database.rollback(sp);
            
            return new Map<String, Object>{
                'success' => false,
                'error' => e.getMessage(),
                'errorType' => e.getTypeName()
            };
        }
    }
    
    // Streaming data for real-time updates
    @AuraEnabled
    public static String subscribeToAccountUpdates(Id accountId) {
        try {
            // Create platform event subscription
            Account_Update_Event__e updateEvent = new Account_Update_Event__e();
            updateEvent.Account_Id__c = accountId;
            updateEvent.Subscriber_Id__c = UserInfo.getUserId();
            updateEvent.Subscription_Type__c = 'REAL_TIME_UPDATES';
            
            Database.SaveResult result = EventBus.publish(updateEvent);
            
            if (result.isSuccess()) {
                return 'Subscription created successfully';
            } else {
                throw new AuraHandledException('Failed to create subscription');
            }
            
        } catch (Exception e) {
            throw new AuraHandledException('Error creating subscription: ' + e.getMessage());
        }
    }
    
    // File upload handling
    @AuraEnabled
    public static Map<String, Object> uploadAccountDocuments(
        Id accountId,
        String fileName,
        String base64Data,
        String contentType
    ) {
        try {
            // Validate file
            validateFileUpload(fileName, base64Data, contentType);
            
            // Create content version
            ContentVersion cv = new ContentVersion();
            cv.Title = fileName;
            cv.PathOnClient = fileName;
            cv.VersionData = EncodingUtil.base64Decode(base64Data);
            cv.ContentType = contentType;
            
            insert cv;
            
            // Link to account
            ContentDocumentLink cdl = new ContentDocumentLink();
            cdl.LinkedEntityId = accountId;
            cdl.ContentDocumentId = [SELECT ContentDocumentId FROM ContentVersion WHERE Id = :cv.Id].ContentDocumentId;
            cdl.ShareType = 'V';
            cdl.Visibility = 'AllUsers';
            
            insert cdl;
            
            return new Map<String, Object>{
                'success' => true,
                'fileId' => cv.Id,
                'message' => 'File uploaded successfully'
            };
            
        } catch (Exception e) {
            throw new AuraHandledException('Error uploading file: ' + e.getMessage());
        }
    }
    
    // Batch operations for bulk updates
    @AuraEnabled
    public static Map<String, Object> bulkUpdateAccounts(List<Map<String, Object>> accountData) {
        try {
            List<Account> accountsToUpdate = new List<Account>();
            List<String> errors = new List<String>();
            
            for (Map<String, Object> data : accountData) {
                try {
                    Account acc = new Account();
                    acc.Id = (Id) data.get('Id');
                    acc.Name = (String) data.get('Name');
                    acc.Industry = (String) data.get('Industry');
                    acc.Rating = (String) data.get('Rating');
                    
                    validateAccountData(acc);
                    accountsToUpdate.add(acc);
                    
                } catch (Exception e) {
                    errors.add('Error processing account ' + data.get('Id') + ': ' + e.getMessage());
                }
            }
            
            // Perform bulk update
            Database.SaveResult[] results = Database.update(accountsToUpdate, false);
            
            Integer successCount = 0;
            for (Integer i = 0; i < results.size(); i++) {
                if (results[i].isSuccess()) {
                    successCount++;
                } else {
                    errors.add('Failed to update account ' + accountsToUpdate[i].Id + ': ' + 
                             results[i].getErrors()[0].getMessage());
                }
            }
            
            // Invalidate cache
            invalidateAccountCache();
            
            return new Map<String, Object>{
                'success' => errors.isEmpty(),
                'successCount' => successCount,
                'totalCount' => accountData.size(),
                'errors' => errors
            };
            
        } catch (Exception e) {
            throw new AuraHandledException('Error in bulk update: ' + e.getMessage());
        }
    }
    
    // Helper methods
    private static String buildAccountQuery(String searchTerm, String industry) {
        String baseQuery = 'SELECT Id, Name, Industry, Rating, AnnualRevenue, Phone, Website ' +
                          'FROM Account WHERE IsPersonAccount = false';
        
        List<String> conditions = new List<String>();
        
        if (String.isNotBlank(searchTerm)) {
            conditions.add('(Name LIKE \'%' + String.escapeSingleQuotes(searchTerm) + '%\' OR ' +
                          'Phone LIKE \'%' + String.escapeSingleQuotes(searchTerm) + '%\')');
        }
        
        if (String.isNotBlank(industry)) {
            conditions.add('Industry = \'' + String.escapeSingleQuotes(industry) + '\'');
        }
        
        if (!conditions.isEmpty()) {
            baseQuery += ' AND ' + String.join(conditions, ' AND ');
        }
        
        return baseQuery + ' ORDER BY Name ASC';
    }
    
    private static String buildCountQuery(String searchTerm, String industry) {
        String baseQuery = 'SELECT COUNT() FROM Account WHERE IsPersonAccount = false';
        
        List<String> conditions = new List<String>();
        
        if (String.isNotBlank(searchTerm)) {
            conditions.add('(Name LIKE \'%' + String.escapeSingleQuotes(searchTerm) + '%\' OR ' +
                          'Phone LIKE \'%' + String.escapeSingleQuotes(searchTerm) + '%\')');
        }
        
        if (String.isNotBlank(industry)) {
            conditions.add('Industry = \'' + String.escapeSingleQuotes(industry) + '\'');
        }
        
        if (!conditions.isEmpty()) {
            baseQuery += ' AND ' + String.join(conditions, ' AND ');
        }
        
        return baseQuery;
    }
    
    private static void validateAccountData(Account account) {
        if (String.isBlank(account.Name)) {
            throw new ValidationException('Account name is required');
        }
        
        if (account.Name.length() > 255) {
            throw new ValidationException('Account name is too long');
        }
        
        // Additional validation logic
    }
    
    private static Map<String, Object> processContacts(Id accountId, List<Contact> contacts) {
        List<Contact> contactsToUpsert = new List<Contact>();
        
        for (Contact con : contacts) {
            con.AccountId = accountId;
            contactsToUpsert.add(con);
        }
        
        Database.UpsertResult[] results = Database.upsert(contactsToUpsert, Contact.Id);
        
        Integer successCount = 0;
        for (Database.UpsertResult result : results) {
            if (result.isSuccess()) {
                successCount++;
            }
        }
        
        return new Map<String, Object>{
            'successCount' => successCount,
            'totalCount' => contacts.size()
        };
    }
    
    private static void validateFileUpload(String fileName, String base64Data, String contentType) {
        // File size validation (5MB limit)
        if (base64Data.length() > 5 * 1024 * 1024) {
            throw new ValidationException('File size exceeds 5MB limit');
        }
        
        // File type validation
        List<String> allowedTypes = new List<String>{'image/jpeg', 'image/png', 'application/pdf'};
        if (!allowedTypes.contains(contentType)) {
            throw new ValidationException('File type not allowed');
        }
    }
    
    private static String generateCacheKey(String method, List<String> parameters) {
        return method + '_' + String.join(parameters, '_').replace(' ', '');
    }
    
    private static void invalidateAccountCache() {
        // Remove cached account data
        // In a real implementation, you might use cache partitions or patterns
        Cache.Org.remove(CACHE_PARTITION + '.getAccounts');
    }
    
    public class ValidationException extends Exception {