Hello,

I'm having an issue with this trigger not firing in Production. Everything works fine in the Sandbox and everything seems active so I'm unsure of what's happening. Any help is much appreciated! I'm supposed to have this live by tomorrow!

trigger OrderDiscountsRollupSummaryTrigger on Discount__c (after insert, after update, after delete, after undelete) {
    if (trigger.isAfter && (trigger.isInsert || trigger.isUpdate || trigger.isUndelete)) {
        OrderDiscountsOTFRollupSummary.rollupotfdiscounts(trigger.new);
        OrderDiscountsMRFRollupSummary.rollupmrfdiscounts(trigger.new);
    }
    else if (trigger.isAfter && trigger.isDelete) {
        OrderDiscountsOTFRollupSummary.rollupotfdiscounts(trigger.old);
        OrderDiscountsMRFRollupSummary.rollupmrfdiscounts(trigger.old);
  }
}

One of my classes is below, they are both pretty much identical.

global class OrderDiscountsMRFRollupSummary implements Database.Batchable<sObject>, Schedulable {

    //Invocable Method
    @InvocableMethod(label='Rollup All MRF Discounts to Order Packages')
    global static void rollupAllMRFDiscounts(List<Discount__c> mrfdiscounts) {
        rollupmrfdiscounts(mrfdiscounts);
    }

    //Batchable Methods
    global Database.QueryLocator start(Database.BatchableContext bc) {
        return Database.getQueryLocator([SELECT Id FROM Order_Location_Package__c]);
    }

    global void execute(Database.BatchableContext context, List<sObject> batch){
        Set<Id> OrderPackageIds = new Set<Id>();

        for (sObject ordpack : batch) {
            OrderPackageIds.add(ordpack.Id);
        }

        summarizemrfdiscounts(OrderPackageIds);
    }

    global void finish(Database.BatchableContext context) {}

    //Schedulable Methods
    global void execute(SchedulableContext context){
        OrderDiscountsMRFRollupSummary batchJob = new OrderDiscountsMRFRollupSummary();
        Database.executeBatch(batchJob);
    }

    //Static Methods
    public static void rollupmrfdiscounts(List<Discount__c> mrfdiscounts) {
        Set<Id> OrderPackageIds = new Set<Id>();

        //Get Order Location Ids from specified mrfdiscounts
        for (Discount__c ordmrfd : mrfdiscounts) {
            OrderPackageIds.add(ordmrfd.Location_Package__c);
        }

        if (OrderPackageIds.isEmpty() == false) {
            /*Execute as a future call so that the user doesn't have to wait around for
            the rollup to finish. Unless, already in a future or batch call state then
            just perform the rollup.*/

                new OrderDiscountsMRFRollupSummary().summarizemrfdiscounts(OrderPackageIds);
        }
    }

    //Public Methods
    public void summarizemrfdiscounts(Set<Id> OrderPackageIds) {
        //Get Order Locations to Update
        List<Order_Location_Package__c> orderpackages = queryOrderPackagesById(OrderPackageIds);

        Map<Id, AggregateResult> results = getmrfdiscountsAmountsByPackageId(OrderPackageIds);

        //Loop Order Locations and set Amounts
        List<Order_Location_Package__c> orderpackagesToUpdate = new List<Order_Location_Package__c>();
        for (Order_Location_Package__c ordpack : orderpackages) {
            double ddis = 0;
            double pdis = 0;

            if (results.containsKey(ordpack.Id)) {
                AggregateResult ar = results.get(ordpack.Id);
                pdis = (double)ar.get('PercentDiscount');
                ddis = (double)ar.get('DollarDiscount');
            }

            //Determine if Amounts have Changed
            if (
                ordpack.Dollar_Discount_MRR__c != ddis || 
                ordpack.Percent_Discount_MRR__c != pdis
                ) 
            {
                
                ordpack.Dollar_Discount_MRR__c = ddis;
                ordpack.Percent_Discount_MRR__c = pdis;
 
                orderpackagesToUpdate.add(ordpack); //Add location to collection to be updated
            }
        }

        if(orderpackagesToUpdate.isEmpty() == false) {
            Database.SaveResult[] saveResults = Database.update(orderpackagesToUpdate, false);
            System.debug(saveResults);
        }
    }
    //Private Methods
    public Map<Id, AggregateResult> getmrfdiscountsAmountsByPackageId(Set<Id> OrderPackageIds) {
        Map<id,AggregateResult> resultsByOrderLocationId= new Map<Id,AggregateResult>();

        //Summarize Discount Amounts by Order Package Id
        AggregateResult[] results = aggregateMRFDiscountAmounts(OrderPackageIds);
        for (AggregateResult result : results) {
            Id orderlocationId = (Id) result.get('OrderPckg');
            resultsByOrderLocationId.put(orderlocationId, result );
        }
        return resultsByOrderLocationId;
    }

    //Query Methods
    private List<Order_Location_Package__c> queryOrderPackagesById(Set<Id> OrderPackageIds) {
        return [SELECT 
                Id,
                Dollar_Discount_MRR__c,
                Percent_Discount_MRR__c

            FROM 
                Order_Location_Package__c
            WHERE 
                Id IN :OrderPackageIds];
    }

    private AggregateResult[] aggregateMRFDiscountAmounts(Set<Id> OrderPackageIds) {
        return [SELECT 
                Location_Package__c OrderPckg,
                SUM(Discount__c) PercentDiscount,
                SUM(Dollar_Discount__c) DollarDiscount

            FROM 
                Discount__c
            WHERE
                Location_Package__c IN :OrderPackageIds AND Fee__c = 'Monthly Recurring Fees'
            GROUP BY 
                Location_Package__c];
    }

}