Flow Builder vs Apex : Quand choisir quoi ?

public class PricingEngine {
    
    public static Decimal calculatePrice(Opportunity opp) {
        return calculatePrice(opp, System.today());
    }
 
    // La date est un paramètre : la remise Q4 devient testable à date fixe.
    // opp doit être requêtée avec Account.Years_as_Customer__c : un enregistrement
    // simplement inséré n'a pas de relation Account chargée (NullPointerException).
    public static Decimal calculatePrice(Opportunity opp, Date pricingDate) {
        Decimal basePrice = opp.Amount;
        Decimal discount = 0;
        
        // Remise progressive par tranche
        if (basePrice > 100000) {
            discount = 0.15; // 15% au-delà de 100k
        } else if (basePrice > 50000) {
            discount = 0.10; // 10% entre 50k et 100k
        } else if (basePrice > 10000) {
            discount = 0.05; // 5% entre 10k et 50k
        }
        
        // Remise supplémentaire si client fidèle
        if (opp.Account.Years_as_Customer__c > 5) {
            discount += 0.05;
        }
        
        // Remise saisonnière (Q4)
        if (pricingDate.month() >= 10) {
            discount += 0.03;
        }
        
        return basePrice * (1 - discount);
    }
}

// Database.AllowsCallouts est obligatoire pour faire des callouts dans un batch. Lancer avec
// Database.executeBatch(new ContactUpdateBatch(), 100) : 1 callout par Contact, 100 au plus par transaction.
public class ContactUpdateBatch implements Database.Batchable<SObject>, Database.AllowsCallouts {
    
    public Database.QueryLocator start(Database.BatchableContext bc) {
        return Database.getQueryLocator([
            SELECT Id, MailingPostalCode, MailingCity 
            FROM Contact 
            WHERE LastModifiedDate < LAST_N_DAYS:365
        ]);
    }
    
    public void execute(Database.BatchableContext bc, List<Contact> scope) {
        // Geocoding API call for each Contact
        Map<Id, Contact> contactsToUpdate = new Map<Id, Contact>();
        
        for (Contact con : scope) {
            // Call external geocoding service
            Geocoding.Result result = GeocodingService.geocode(
                con.MailingPostalCode, 
                con.MailingCity
            );
            
            if (result.success) {
                con.Geolocation__Latitude__s = result.latitude;
                con.Geolocation__Longitude__s = result.longitude;
                contactsToUpdate.put(con.Id, con);
            }
        }
        
        if (!contactsToUpdate.isEmpty()) {
            update contactsToUpdate.values();
        }
    }
    
    public void finish(Database.BatchableContext bc) {
        // Send completion email
        Messaging.SingleEmailMessage mail = new Messaging.SingleEmailMessage();
        mail.setToAddresses(new String[] {'admin@company.com'});
        mail.setSubject('Contact Geocoding Batch Completed');
        mail.setPlainTextBody('Batch job finished successfully.');
        Messaging.sendEmail(new Messaging.SingleEmailMessage[] { mail });
    }
}

public class ERPIntegrationService {
    
    @future(callout=true)
    public static void syncOrderToERP(Id orderId) {
        Order order = [
            SELECT Id, OrderNumber, TotalAmount, Account.Name, 
                   (SELECT Product2.Name, Quantity, UnitPrice FROM OrderItems)
            FROM Order 
            WHERE Id = :orderId
        ];
        
        // Construct JSON payload
        Map<String, Object> payload = new Map<String, Object>{
            'orderNumber' => order.OrderNumber,
            'customer' => order.Account.Name,
            'totalAmount' => order.TotalAmount,
            'items' => buildOrderItems(order.OrderItems)
        };
        
        // HTTP Callout
        HttpRequest req = new HttpRequest();
        req.setEndpoint('callout:ERP_API/orders');
        req.setMethod('POST');
        req.setHeader('Content-Type', 'application/json');
        req.setBody(JSON.serialize(payload));
        req.setTimeout(120000);
        
        Http http = new Http();
        HttpResponse res = http.send(req);
        
        if (res.getStatusCode() == 201) {
            // Parse response and update Order with ERP ID
            Map<String, Object> responseData = 
                (Map<String, Object>) JSON.deserializeUntyped(res.getBody());
            
            order.ERP_Order_ID__c = (String) responseData.get('erpOrderId');
            order.ERP_Sync_Status__c = 'Synced';
            update order;
        } else {
            throw new ERPIntegrationException('ERP sync failed: ' + res.getBody());
        }
    }
    
    private static List<Map<String, Object>> buildOrderItems(List<OrderItem> items) {
        List<Map<String, Object>> result = new List<Map<String, Object>>();
        for (OrderItem item : items) {
            result.add(new Map<String, Object>{
                'productName' => item.Product2.Name,
                'quantity' => item.Quantity,
                'unitPrice' => item.UnitPrice
            });
        }
        return result;
    }
}

@isTest
private class PricingEngine_Test {
    
    @isTest
    static void testCalculatePrice_BaseDiscount() {
        // Arrange
        Account acc = new Account(Name = 'Test Corp', Years_as_Customer__c = 3);
        insert acc;
        
        Opportunity opp = new Opportunity(
            Name = 'Test Deal',
            AccountId = acc.Id,
            Amount = 60000,
            StageName = 'Prospecting',
            CloseDate = Date.today().addDays(30)
        );
        insert opp;
        // Requêter le champ de relation lu par PricingEngine (sinon NullPointerException)
        opp = [SELECT Id, Amount, Account.Years_as_Customer__c FROM Opportunity WHERE Id = :opp.Id];
        
        // Act
        Test.startTest();
        // Date fixe hors Q4 : le résultat ne dépend pas du jour d'exécution du test
        Decimal finalPrice = PricingEngine.calculatePrice(opp, Date.newInstance(2026, 3, 15));
        Test.stopTest();
        
        // Assert
        Decimal expected = 60000 * 0.90; // 10% discount
        System.assertEquals(expected, finalPrice, 
            'Price should have 10% discount for amount between 50k-100k');
    }
    
    @isTest
    static void testCalculatePrice_LoyalCustomer() {
        // Arrange
        Account acc = new Account(Name = 'Loyal Corp', Years_as_Customer__c = 7);
        insert acc;
        
        Opportunity opp = new Opportunity(
            Name = 'Test Deal',
            AccountId = acc.Id,
            Amount = 60000,
            StageName = 'Prospecting',
            CloseDate = Date.today().addDays(30)
        );
        insert opp;
        // Requêter le champ de relation lu par PricingEngine (sinon NullPointerException)
        opp = [SELECT Id, Amount, Account.Years_as_Customer__c FROM Opportunity WHERE Id = :opp.Id];
        
        // Act
        Test.startTest();
        // Date fixe hors Q4 : le résultat ne dépend pas du jour d'exécution du test
        Decimal finalPrice = PricingEngine.calculatePrice(opp, Date.newInstance(2026, 3, 15));
        Test.stopTest();
        
        // Assert
        Decimal expected = 60000 * 0.85; // 10% base + 5% loyalty
        System.assertEquals(expected, finalPrice, 
            'Loyal customer should get additional 5% discount');
    }
}

public class SIRETValidator {
    
    @InvocableMethod(label='Validate SIRET' 
                     description='Validates French SIRET number via external API'
                     callout=true)
    public static List<Result> validateSIRET(List<Request> requests) {
        List<Result> results = new List<Result>();
        
        // Un callout par requête : 100 au plus par transaction, à garder en tête pour les gros volumes
        for (Request req : requests) {
            Result result = new Result();
            result.isValid = callSIRETAPI(req.siretNumber);
            results.add(result);
        }
        
        return results;
    }
    
    private static Boolean callSIRETAPI(String siret) {
        // HTTP Callout to SIRENE API
        HttpRequest req = new HttpRequest();
        req.setEndpoint('callout:SIRENE_API/siret/' + siret);
        req.setMethod('GET');
        
        Http http = new Http();
        HttpResponse res = http.send(req);
        
        return res.getStatusCode() == 200;
    }
    
    public class Request {
        @InvocableVariable(required=true)
        public String siretNumber;
    }
    
    public class Result {
        @InvocableVariable
        public Boolean isValid;
    }
}