Loading
Creazione di trigger per i calcoli delle previsioni account avanzate

Creazione di trigger per i calcoli delle previsioni account avanzate

Se si utilizzano oggetti Fatto delle previsioni account avanzate personalizzati per le previsioni, è possibile creare trigger per calcolare le previsioni per gli account anziché utilizzare l'azione invocabile CalculateAdvancedForecast nel flusso. Un trigger è un Apex Code che viene eseguito prima o dopo che si sono verificati eventi DML (Data Manipulation Language) specifici, ad esempio prima che i record di oggetti vengano inseriti nel database o dopo che i record sono stati eliminati.

Versioni (Edition) richieste

Disponibile in: Lightning Experience
Disponibile in: Enterprise Edition, Unlimited Edition e Developer Edition
Autorizzazioni utente richieste
Per creare i trigger: Personalizza applicazione
  1. Da Imposta, aprire il Gestore oggetti.
  2. Fare clic sull'oggetto Fatto delle previsioni account avanzate personalizzato.
  3. Fare clic su Trigger e quindi su Nuovo.
  4. Definire un trigger con la formula di calcolo delle previsioni e salvare il lavoro.

    Il trigger deve includere i tre file XML indicati sotto.

    • CustomForecastFactFormulaEvaluator.cls
    • CustomForecastFactUtil.cls
    • CustomForecastFactTrigger.trigger

    Se si devono aggiungere, è necessario crearli nell'ordine in cui sono specificati qui. Se sono già presenti nel sistema e vengono distribuiti con l'API dei metadati, l'ordine viene stabilito dalla distribuzione.

    Ad esempio, un trigger per un oggetto CustomForecastFact__c che calcola la quantità e il reddito della previsione e inserisce i valori nel record Fatto personalizzato ha questi tre file XML.

    public class CustomForecastFactFormulaEvaluator {
        
        Map<String, String> calculationFrequencyToPeriodTypeMap = new Map<String, String> {
            'Yearly' => 'Year', 'Quarterly' => 'Quarter', 'Monthly' => 'Month', 'Weekly' => 'Week'
        };
        
        static Map<Id, AdvAcctForecastSetPartner> partnerMap;
        static Map<Id, AdvAccountForecastSet> forecastSetMap;
        static Map<Id, AdvAcctForecastPeriodGroup> periodGroupMap;
        static Map<String, List<Period>> periodsMap;
        static Map<String, Period> currentPeriodMap;
        static Map<String, Period> pastPeriodMap;
        static Map<String, Period> futurePeriodMap;
        static Map<Id, Map<Integer, AdvAccountForecastFormula>> quantityFormulaMap;
        static Map<Id, Map<Integer, AdvAccountForecastFormula>> revenueFormulaMap;
        
    	AdvAcctForecastSetPartner partner;
        AdvAccountForecastSet forecastSet;
        AdvAcctForecastPeriodGroup periodGroup;
        Map<Integer, AdvAccountForecastFormula> quantityFormulaByPeriod;
        Map<Integer, AdvAccountForecastFormula> revenueFormulaByPeriod;
        Date forecastStartDate;
        List<Period> periods;
        List<Date> periodStartDates;
        static Map<Id, CustomForecastFactFormulaEvaluator> partnerCache = new Map<Id, CustomForecastFactFormulaEvaluator>();
            
        public static void initialize(Set<Id> partnerIds) {
            partnerMap = loadForecastSetPartners(partnerIds);
            forecastSetMap = loadForecastSets(partnerMap.values());
            periodGroupMap = loadForecastPeriodGroups(forecastSetMap.values());
            periodsMap = loadPeriods();
            pastPeriodMap = loadPastPeriodMap();
            currentPeriodMap = loadCurrentPeriodMap();
            futurePeriodMap = loadFuturePeriodMap();
            loadForecastFormulas(forecastSetMap.keySet());
        }
        
        private CustomForecastFactFormulaEvaluator(Id forecastSetPartnerId) {
            partner = loadForecastSetPartner(forecastSetPartnerId);
            forecastSet = loadForecastSet(partner.AdvAccountForecastSetId);
            periodGroup = loadForecastPeriodGroup(forecastSet.ForecastPeriodGroupId);
            loadForecastFormulas(forecastSet.Id);
            periods = loadPeriods(resolvePeriodTypeFromCalculationFrequency(forecastSet.CalculationFrequency));
            periodStartDates = extractPeriodStartDates(periods);
            forecastStartDate = getForecastStartDate(resolvePeriodTypeFromCalculationFrequency(forecastSet.CalculationFrequency), periodGroup.StartPeriod);
        }
        
        public static CustomForecastFactFormulaEvaluator getInstance(Id forecastSetPartnerId) {
            if(!partnerCache.containsKey(forecastSetPartnerId)) {
                partnerCache.put(forecastSetPartnerId, new CustomForecastFactFormulaEvaluator(forecastSetPartnerId));
            }
            return partnerCache.get(forecastSetPartnerId);
        }
        
        private AdvAcctForecastSetPartner loadForecastSetPartner(Id forecastSetPartnerId) {
            return partnerMap.get(forecastSetPartnerId);
        }
        
        private static Map<Id, AdvAcctForecastSetPartner> loadForecastSetPartners(Set<Id> forecastSetPartnerIds) {
            return new Map<Id, AdvAcctForecastSetPartner>([SELECT Id, AdvAccountForecastSetId FROM AdvAcctForecastSetPartner WHERE Id IN : forecastSetPartnerIds]);
        }
        
        private AdvAccountForecastSet loadForecastSet(Id forecastSetId) {
            return forecastSetMap.get(forecastSetId);
        }
        
        private static Map<Id, AdvAccountForecastSet> loadForecastSets(List<AdvAcctForecastSetPartner> partners) {
            Set<Id> forecastSetIds = new Set<Id>();
            for (AdvAcctForecastSetPartner partner : partners) {
                forecastSetIds.add(partner.AdvAccountForecastSetId);
            }
            return new Map<Id, AdvAccountForecastSet>([SELECT Id, ForecastPeriodGroupId, CalculationFrequency FROM AdvAccountForecastSet WHERE Id IN :forecastSetIds]);
        }
        
        private AdvAcctForecastPeriodGroup loadForecastPeriodGroup(Id forecastPeriodGroupId) {
            return periodGroupMap.get(forecastPeriodGroupId);
        }
        
        private static Map<Id, AdvAcctForecastPeriodGroup> loadForecastPeriodGroups(List<AdvAccountForecastSet> forecastSets) {
            Set<Id> forecastPeriodGroupIds = new Set<Id>();
            for (AdvAccountForecastSet forecastSet : forecastSets) {
                forecastPeriodGroupIds.add(forecastSet.ForecastPeriodGroupId);
            }
            return new Map<Id, AdvAcctForecastPeriodGroup>([SELECT Id, StartPeriod FROM AdvAcctForecastPeriodGroup WHERE Id IN :forecastPeriodGroupIds]);
        }
        
        private void loadForecastFormulas(Id forecastSetId) {
            quantityFormulaByPeriod = quantityFormulaMap.get(forecastSetId);
            revenueFormulaByPeriod = revenueFormulaMap.get(forecastSetId);
        }
        
        private static void loadForecastFormulas(Set<Id> forecastSetIds) {
            List<AdvAccountForecastFormula> formulaList = [SELECT Id, AdvAccountForecastSetId, FormulaType, StartPeriod, EndPeriod, FormulaExpression FROM AdvAccountForecastFormula WHERE AdvAccountForecastSetId IN :forecastSetIds];
            
            quantityFormulaMap = new Map<Id, Map<Integer, AdvAccountForecastFormula>>();
            revenueFormulaMap = new Map<Id, Map<Integer, AdvAccountForecastFormula>>();
            
            for(AdvAccountForecastFormula formula : formulaList) {
                Id forecastSetId = formula.AdvAccountForecastSetId;
                
                if(!quantityFormulaMap.containsKey(forecastSetId)) quantityFormulaMap.put(forecastSetId, new Map<Integer, AdvAccountForecastFormula>());
                if(!revenueFormulaMap.containsKey(forecastSetId)) revenueFormulaMap.put(forecastSetId, new Map<Integer, AdvAccountForecastFormula>());
                
                switch on formula.FormulaType {
                    when 'QUANTITY' {
                        for (Integer i = formula.StartPeriod; i <= formula.EndPeriod; i++) {
                            quantityFormulaMap.get(forecastSetId).put(i, formula);
                        }
                    }
                    when 'REVENUE' {
                        for (Integer i = formula.StartPeriod; i <= formula.EndPeriod; i++) {
                            revenueFormulaMap.get(forecastSetId).put(i, formula);
                        }
                    }
                }
            }
        }
        
        private List<Period> loadPeriods(String periodType) {
            return periodsMap.get(periodType);
        }
        
        private static Map<String, List<Period>> loadPeriods() {
            Map<String, List<Period>> periodsMap = new Map<String, List<Period>>();
            List<Period> periods = [SELECT Id, Type, StartDate FROM Period ORDER BY Type, StartDate];
            for (Period period : periods) {
                if(!periodsMap.containsKey(period.Type)) {
                    periodsMap.put(period.Type, new List<Period>{period});
                } else {
                    periodsMap.get(period.Type).add(period);
                }
            }
            return periodsMap;
        }
        
        private List<Date> extractPeriodStartDates(List<Period> periods) {
            List<Date> startDateList = new List<Date>();
            for(Period period : periods) {
                startDateList.add(period.StartDate);
            }
            return startDateList;
        }
        
        private Date getForecastStartDate(String periodType, Integer startPeriod) {
            Period forecastStartPeriod;
            
            if(startPeriod == 0) {
            	forecastStartPeriod = getCurrentPeriod(periodType);   
            } else {
                forecastStartPeriod = getPeriodByOffset(periodType, startPeriod);
            }
            
            return forecastStartPeriod.StartDate;
        }
        
        private Period getCurrentPeriod(String periodType) {
            return currentPeriodMap.get(periodType);
        }
        
        private static Map<String, Period> loadPastPeriodMap() {
            Map<String, Period> periodMap = new Map<String, Period>();
            Date today = Date.today();
            List<Period> periods = [SELECT Id, Type, StartDate, EndDate FROM Period WHERE StartDate <= :today AND EndDate <= :today LIMIT 1];
            for(Period period : periods) {
                periodMap.put(period.Type, period);
            }
            return periodMap;
        }
        
        private static Map<String, Period> loadCurrentPeriodMap() {
            Map<String, Period> periodMap = new Map<String, Period>();
            Date today = Date.today();
            List<Period> periods = [SELECT Id, Type, StartDate, EndDate FROM Period WHERE StartDate >= :today AND EndDate <= :today LIMIT 1];
            for(Period period : periods) {
                periodMap.put(period.Type, period);
            }
            return periodMap;
        }
        
        private static Map<String, Period> loadFuturePeriodMap() {
            Map<String, Period> periodMap = new Map<String, Period>();
            Date today = Date.today();
            List<Period> periods = [SELECT Id, Type, StartDate, EndDate FROM Period WHERE EndDate >= :today AND EndDate <= :today LIMIT 1];
            for(Period period : periods) {
                periodMap.put(period.Type, period);
            }
            return periodMap;
        }
        
        private Period getPeriodByOffset(String periodType, Integer startPeriod) {
            Date today = Date.today();
            if (startPeriod < 0) {
                return pastPeriodMap.get(periodType);
            } else if (startPeriod > 0) {
                return futurePeriodMap.get(periodType);
            } else {
                return getCurrentPeriod(periodType);
            }
        }
        
        public void eval(List<CustomForecastFact__c> forecastFacts) {
            List<FactWrapper> factWrapperList = createFactRecordPeriodStartDatePair(forecastFacts);
            for (FactWrapper wrapper : factWrapperList) {
                CustomForecastFact__c fact = wrapper.fact;
                Date factStartDate = wrapper.startDate;
                
                Integer periodNumber = getPeriodNumber(forecastStartDate, factStartDate);
                
                // Here is the place where we can apply formula based on various conditions.
                // What we see below is just an example.
                Double dummyFactor = 1;
                fact.ForecastedQuantity__c = dummyFactor * (nvl(fact.OpportunityQuantity__c) + nvl(fact.OrderQuantity__c) + nvl(fact.LastYearOrderQuantity__c) + nvl(fact.SalesAgreementQuantity__c));
                fact.ForecastedRevenue__c = dummyFactor * (nvl(fact.OpportunityRevenue__c) + nvl(fact.OrderRevenue__c) + nvl(fact.LastYearOrderRevenue__c) + nvl(fact.SalesAgreementRevenue__c));
            }
        }
        
        private Double nvl(Decimal input) {
            if (input == null ) return 0;
            return nvl(input.doubleValue(), 0);
        }
        
        private Double nvl(Double input) {
            return nvl(input, 0);
        }
        
        private Double nvl(Double input, Double defaultVal) {
            if (input == null) return defaultVal;
            return input;
        }
        
        private Integer getPeriodNumber(Date forecastStartDate, Date forecastFactStartDate) {
            if (forecastFactStartDate < forecastStartDate) {
                // For Past Period we will always use the formula defined for period 1.
                return 1;
            }
            Integer forecastStartDatePeriodNumber = periodStartDates.indexOf(forecastStartDate);
            Integer forecactFactStartDatePeriodNumber = periodStartDates.indexOf(forecastFactStartDate);
            return forecactFactStartDatePeriodNumber - forecastStartDatePeriodNumber + 1;
        }
        
        private String resolvePeriodTypeFromCalculationFrequency(String calculationFrequency) {
            return calculationFrequencyToPeriodTypeMap.get(calculationFrequency);
        }
        
        private List<FactWrapper> createFactRecordPeriodStartDatePair(List<CustomForecastFact__c> forecastFacts) {
            List<FactWrapper> wrapperList = new List<FactWrapper>();
            
            Map<Id, Period> periodMapById = new Map<Id, Period>(periods);
            for(CustomForecastFact__c fact : forecastFacts) {
                wrapperList.add(new FactWrapper(fact, periodMapById.get(fact.Period__c).StartDate));
            }
            
            return wrapperList;
        }
        
        private class FactWrapper {
            CustomForecastFact__c fact;
            Date startDate;
            
            FactWrapper(CustomForecastFact__c fact, Date startDate) {
                this.fact = fact;
                this.startDate = startDate;
            }
        }
    }
    public class CustomForecastFactUtil {
    	public static void calculateForecast(Set<Id> forecastFactIds) {
            List<CustomForecastFact__c> forecastFacts = loadForecastFacts(forecastFactIds);
            
            // Map of Facts by PartnerId
            Map<Id, List<CustomForecastFact__c>> factMapByPartnerId = new Map<Id, List<CustomForecastFact__c>>();
            for(CustomForecastFact__c fact : forecastFacts) {
                Id partnerId = fact.AdvAcctForecastSetPartner__c;
                if (!factMapByPartnerId.containsKey(partnerId)) {
                    factMapByPartnerId.put(partnerId, new List<CustomForecastFact__c> {fact});
                } else {
                    factMapByPartnerId.get(partnerId).add(fact);
                }
            }
    ​
            CustomForecastFactFormulaEvaluator.initialize(factMapByPartnerId.keySet());        
            for(Id partnerId : factMapByPartnerId.keySet()) {
                CustomForecastFactFormulaEvaluator formulaEvaluator = CustomForecastFactFormulaEvaluator.getInstance(partnerId);
                formulaEvaluator.eval(factMapByPartnerId.get(partnerId));
            }
            
            update forecastFacts;
        }
        
        private static List<CustomForecastFact__c> loadForecastFacts(Set<Id> forecastFactIds) {
            return [
                SELECT Id, AdvAcctForecastSetPartner__c, OrderQuantity__c, OrderRevenue__c, OpportunityQuantity__c, OpportunityRevenue__c
                  , SalesAgreementQuantity__c, SalesAgreementRevenue__c, LastYearOrderQuantity__c, LastYearOrderRevenue__c
                  , ForecastedQuantity__c, ForecastedRevenue__c, Period__c
                FROM CustomForecastFact__c
                WHERE Id IN :forecastFactIds
            ];
        }
    }
    trigger CustomForecastFactTrigger on CustomForecastFact__c (after insert) {
        CustomForecastFactUtil.calculateForecast(Trigger.newMap.keySet());
    }
 
Caricamento
Salesforce Help | Article