1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
trigger kell01_OpportunityTrigger on Opportunity (before insert, before update, after insert, after update) {
    if (trigger.isBefore) { // SetOpportunityHousehold
        Set<Id> donorIds = new Set<Id>();
        for (Opportunity opp : trigger.new) {
            if (opp.AccountId != null) {
                donorIds.add(opp.AccountId);
            } else {
                opp.Household__c = null;
            }
        }
        if (!donorIds.isEmpty()) {
            Map<Id, Account> donors = new Map<Id, Account>([SELECT Id, npe01__One2OneContact__r.npo02__Household__c, npe01__One2OneContact__r.npo02__Household__r.Name, npe01__One2OneContact__r.Account.Name 
                                                            FROM Account WHERE Id IN :donorIds AND npe01__One2OneContact__c != null AND npe01__SYSTEM_AccountType__c != 'Household Account']);
            for (Opportunity opp : trigger.new) {
                if (opp.AccountId != null && donors.containsKey(opp.AccountId)) {
                    Account donor = donors.get(opp.AccountId);
                    opp.Household__c = donor.npe01__One2OneContact__r.npo02__Household__c;
                    //opp.Household_or_Account_Name__c = donor.npe01__One2OneContact__r.npo02__Household__r.Name != null ? donor.npe01__One2OneContact__r.npo02__Household__r.Name : donor.npe01__One2OneContact__r.Account.Name;
                }
            }
        }
    } else if (trigger.isAfter) { // CreateDefaultAllocation
        Allocation_Settings__c setting = Allocation_Settings__c.getOrgDefaults();
        Set<Id> campaignIds = new Set<Id>();
        for (Opportunity opp : trigger.new) campaignIds.add(opp.CampaignId);
        Map<Id, Campaign> campaigns = new Map<Id, Campaign>([SELECT Id, Primary_Fund__c FROM Campaign WHERE Id IN :campaignIds]);
        
        Map<Id, List<Allocation__c>> defaultDesignations = new Map<Id, List<Allocation__c>>();
        Set<Id> accountIds = new Set<Id>();
        Set<String> fiscalYears = new Set<String>();
        Integer fyStart = [SELECT Id, FiscalYearStartMonth FROM Organization LIMIT 1].FiscalYearStartMonth;
        for (Opportunity opp : trigger.new) {
            if (!opp.Do_Not_Update_Projection_Allocations__c) {
                accountIds.add(opp.AccountId);
                fiscalYears.add(String.valueOf(opp.CloseDate.Year() + (opp.CloseDate.Month() > fyStart && fyStart > 1 ? 1 : 0)));
            }
        }

        Map<Id, Map<Decimal, Projection__c>> projections = new Map<Id, Map<Decimal, Projection__c>>();
        for (Projection__c p : [SELECT Id, Account__c, Fiscal_Year__c, Projection_Allocation_Primary_Fund__c FROM Projection__c WHERE Account__c IN :accountIds AND Fiscal_Year__c IN :fiscalYears]) {
            if (!projections.containsKey(p.Account__c)) projections.put(p.Account__c, new Map<Decimal, Projection__c>());
            projections.get(p.Account__c).put(Integer.valueOf(p.Fiscal_Year__c), p);
        }
        
        for (Opportunity opp : trigger.new) {
            if ((setting.Opportunity_Record_Type_Exclusion_List__c == null || !setting.Opportunity_Record_Type_Exclusion_List__c.contains(opp.RecordTypeId)) 
             && !opp.Do_Not_Automatically_Create_Allocation__c && opp.Amount != null && opp.Amount > 0 
             && (trigger.isInsert || trigger.oldMap.get(opp.Id).Amount == null || trigger.oldMap.get(opp.Id).Amount == 0)) {
                Id primaryFund = null;
                Integer fy = opp.CloseDate.Year() + (opp.CloseDate.Month() > fyStart && fyStart > 1 ? 1 : 0);
                if (!opp.Do_Not_Update_Projection_Allocations__c && projections.containsKey(opp.AccountId) && projections.get(opp.AccountId).containsKey(fy) && projections.get(opp.AccountId).get(fy).Projection_Allocation_Primary_Fund__c != null) {
                    primaryFund = projections.get(opp.AccountId).get(fy).Projection_Allocation_Primary_Fund__c;
                } else if (opp.Primary_Fund__c != null) {
                    primaryFund = opp.Primary_Fund__c;
                } else if (campaigns.containsKey(opp.CampaignId) && campaigns.get(opp.CampaignId).Primary_Fund__c != null) {
                    primaryFund = campaigns.get(opp.CampaignId).Primary_Fund__c;
                } else if (setting.Set_Default_Fund__c && setting.Default_Fund__c != null) {
                    primaryFund = setting.Default_Fund__c;
                }
                
                if (primaryFund != null) {
                    defaultDesignations.put(
                        opp.Id,
                        new List<Allocation__c>{
                            new Allocation__c(
                            Opportunity__c = opp.Id,
                            Projection__c = projections.containsKey(opp.AccountId) && projections.get(opp.AccountId).containsKey(fy) ? projections.get(opp.AccountId).get(fy).Id : null,
                            Fund__c = primaryFund,
                            Amount__c = opp.Amount
                            )
                        }
                    );
                }
            }
        }
        if (!defaultDesignations.isEmpty()) {
            for (Allocation__c a : [SELECT Id, Opportunity__c FROM Allocation__c WHERE Opportunity__c IN :defaultDesignations.keySet()]) {
                if (defaultDesignations.containsKey(a.Opportunity__c)) defaultDesignations.remove(a.Opportunity__c);
            }
            List<Allocation__c> toInsert = new List<Allocation__c>();
            for (List<Allocation__c> aList : defaultDesignations.values()) toInsert.addAll(aList);
            insert toInsert;
        }
    
        if (trigger.isUpdate) { // CHANGE PRIMARY FUND ON A SINGLE ALLOCATION + CHANGE ALLOCATED AMOUNTS IF OPPORTUNITY AMOUNT CHANGES + CREATE NEW ALLOCATION IF ALL ARE REVERSED
            Map<Id, Id> primaryFunds = new Map<Id, Id>();
            Set<Id> oppsWithChangedAmount = new Set<Id>();
            Set<Id> repostedOpps = new Set<Id>();
            for (Opportunity opp : trigger.new) {        
                if (opp.Primary_Fund__c != trigger.oldMap.get(opp.Id).Primary_Fund__c && opp.Primary_Fund__c != null) {
                    primaryFunds.put(opp.Id, opp.Primary_Fund__c);
                }
                if (opp.Amount != trigger.oldMap.get(opp.Id).Amount && trigger.oldMap.get(opp.Id).Amount != null && trigger.oldMap.get(opp.Id).Amount > 0) {
                    oppsWithChangedAmount.add(opp.Id);
                }
                if (opp.Opportunity_Posted__c && !trigger.oldMap.get(opp.Id).Opportunity_Posted__c && trigger.oldMap.get(opp.Id).Opportunity_Reversed__c) {
                    repostedOpps.add(opp.Id);
                }
            }
            if (!primaryFunds.isEmpty()) {
                List<Allocation__c> toUpdate = new List<Allocation__c>();
                List<Allocation__c> toInsert = new List<Allocation__c>();
                for (Opportunity opp : [SELECT Id, Amount, CloseDate, (SELECT Id, Fund__c FROM Allocations__r WHERE Reversed__c = false) FROM Opportunity WHERE Id IN :primaryFunds.keySet()]) {
                    if (opp.Allocations__r.size() == 1 && opp.Allocations__r[0].Fund__c != primaryFunds.get(opp.Id)) {
                        toUpdate.add(new Allocation__c(Id = opp.Allocations__r[0].Id, Fund__c = primaryFunds.get(opp.Id)));
                    } else if (opp.Allocations__r.size() == 0) {
                        Integer fy = opp.CloseDate.Year() + (opp.CloseDate.Month() > fyStart && fyStart > 1 ? 1 : 0);
                        toInsert.add(new Allocation__c(Opportunity__c = opp.Id, Projection__c = projections.containsKey(opp.AccountId) && projections.get(opp.AccountId).containsKey(fy) ? projections.get(opp.AccountId).get(fy).Id : null, Fund__c = primaryFunds.get(opp.Id), Amount__c = opp.Amount));
                    }
                }
                update toUpdate;
                insert toInsert;
            }
            if (!oppsWithChangedAmount.isEmpty()) {
                List<Allocation__c> toUpdate = new List<Allocation__c>();
                List<Allocation__c> toDelete = new List<Allocation__c>();
                for (Opportunity opp : [SELECT Id, Amount, Allocated_Amount__c, (SELECT Id, Amount__c FROM Allocations__r WHERE Reversed__c = false) FROM Opportunity WHERE Id IN :oppsWithChangedAmount]) {
                    if (opp.Amount != opp.Allocated_Amount__c) {
                        Double oldAmount = trigger.oldMap.get(opp.Id).Amount;
                        Double allocated = 0;
                        List<Allocation__c> allToUpdate = new List<Allocation__c>();
                        List<Allocation__c> allToDelete = new List<Allocation__c>();
                        for (Allocation__c a : opp.Allocations__r) {
                            Decimal newAllocAmount = (a.Amount__c * opp.Amount / oldAmount).setScale(2, RoundingMode.HALF_UP);
                            if (newAllocAmount > 0) {
                                allToUpdate.add(new Allocation__c(Id = a.Id, Amount__c = newAllocAmount));
                                allocated += newAllocAmount;
                            } else {
                                allToDelete.add(new Allocation__c(Id = a.Id));
                            }
                        }
                        if (allocated != opp.Amount) { // rounding inaccuracy
                            if (!allToUpdate.isEmpty()) {
                                allToUpdate[allToUpdate.size()-1].Amount__c += (opp.Amount-allocated);
                            } else if (!allToDelete.isEmpty() && opp.Amount > allocated) {
                                Allocation__c a = allToDelete.remove(allToDelete.size()-1);
                                a.Amount__c = (opp.Amount-allocated);
                                allToUpdate.add(a);
                            }
                        }
                        toUpdate.addAll(allToUpdate);
                        toDelete.addAll(allToDelete);
                    }
                }
                delete toDelete;
                update toUpdate;
            }
            if (!repostedOpps.isEmpty()) {
                List<Allocation__c> toInsert = new List<Allocation__c>();
                for (Opportunity opp : [SELECT Id, Primary_Fund__c, (SELECT Id, Fund__c, Amount__c, Reversed__c, Reversed_Date__c FROM Allocations__r ORDER BY Reversed__c ASC) 
                                        FROM Opportunity WHERE Id IN :repostedOpps]) {
                    if (!opp.Allocations__r.isEmpty() && opp.Allocations__r[0].Reversed__c) {
                        for (Allocation__c a : opp.Allocations__r) {
                            if (a.Reversed_Date__c >= trigger.OldMap.get(opp.Id).Opportunity_Reversed_Date__c) {
                                Allocation__c newA = new Allocation__c(Opportunity__c = opp.Id, Fund__c = a.Fund__c, Amount__c = a.Amount__c, Posted__c = true);
                                if (!toInsert.isEmpty() && a.Fund__c == opp.Primary_Fund__c) toInsert.add(0, newA);
                                else toInsert.add(newA);
                            }
                        }
                    }
                }
                if (setting.Lock_Allocation_if_Opportunity_is_Posted__c) {
                    setting.Lock_Allocation_if_Opportunity_is_Posted__c = false;
                    update setting;
                    insert toInsert;
                    setting.Lock_Allocation_if_Opportunity_is_Posted__c = true;
                    update setting;
                } else {
                    insert toInsert;
                }
            }
        }
        
        // VALIDATION
        if (setting.Check_Max_Allocated_Amount__c) {
            Map<Id, Opportunity> opportunities = new Map<Id, Opportunity>([SELECT Id, Amount, (SELECT Id, Amount__c FROM Allocations__r WHERE Reversed__c = false) FROM Opportunity WHERE Id IN :trigger.new]);
            for (Opportunity opp : trigger.new) {
                Double allocatedAmount = 0;
                for (Allocation__c a : opportunities.get(opp.Id).Allocations__r) {
                    allocatedAmount += a.Amount__c;
                }
                if (allocatedAmount > 0 && allocatedAmount > opportunities.get(opp.Id).Amount) {
                    opp.addError('Total allocated amount cannot exceed opportunity amount.');
                }
            }
        }
    }
    
    if (trigger.isUpdate) { // PostUnpostAllAllocationsOnOpportunity
        Set<Id> opportunitiesToPost = new Set<Id>();
        Set<Id> opportunitiesToUnpost = new Set<Id>();
        for (Opportunity opp : trigger.new) {
            if (trigger.isInsert || trigger.isUndelete || opp.Opportunity_Posted__c != trigger.oldMap.get(opp.Id).Opportunity_Posted__c) {
                if (opp.Opportunity_Posted__c) {
                    opportunitiesToPost.add(opp.Id);
                } else {
                    opportunitiesToUnpost.add(opp.Id);
                }
            }
        }
        
        if (trigger.isBefore && !opportunitiesToPost.isEmpty()) {
            List<Allocation__c> allocationsToPost = [SELECT Id FROM Allocation__c 
                                                               WHERE Opportunity__c IN :opportunitiesToPost AND Posted__c = false AND Reversed__c = false
                                                                 AND Opportunity__r.Opportunity_Posted__c = false AND Opportunity__r.All_Payments_Posted__c = false];
            for (Allocation__c a : allocationsToPost) {
                a.Posted__c = true;
                a.Reversed__c = false;
            }
            update allocationsToPost;
        }
        
        if (trigger.isAfter && !opportunitiesToUnpost.isEmpty()) {
            List<Allocation__c> allocationsToUnpost = [SELECT Id FROM Allocation__c 
                                                               WHERE Opportunity__c IN :opportunitiesToUnpost AND Posted__c = true AND Reversed__c = false
                                                                 AND Opportunity__r.Opportunity_Posted__c = false AND Opportunity__r.All_Payments_Posted__c = false];
            for (Allocation__c a : allocationsToUnpost) {
                a.Posted__c = false;
            }
            update allocationsToUnpost;
        }
    }
}