Content Comparison

public abstract class USYD_TriggerHandlerBase {
    private final string ALL_TRIGGER_KEY = 'USYD_ALL_TRIGGERS';   
    private final TriggerOperation TEST_DEFAULT_OP = TriggerOperation.BEFORE_INSERT;   
    private String triggerName = '-Untitled-';
    @testvisible private USYD_Trigger_Setting__mdt allTriggerConfig = USYD_Trigger_Setting__mdt.getInstance(ALL_TRIGGER_KEY);
    @testvisible private USYD_Trigger_Setting__mdt triggerConfig = null; 
    USYD_System_Config__c config = USYD_System_Config__c.getInstance();    
    
    public virtual void beforeInsert(List<SObject> newRecords){}
    public virtual void beforeUpdate(List<SObject> oldRecords, List<SObject> newRecords, Map<ID, SObject> oldRecordMap, Map<ID, SObject> newRecordMap){}
    public virtual void beforeDelete(List<SObject> oldRecords, Map<ID, SObject> oldRecordMap){}
    public virtual void afterInsert(List<SObject> newRecords, Map<ID, SObject> newRecordMap){}
    public virtual void afterUpdate(List<SObject> oldRecords, List<SObject> newRecords, Map<ID, SObject> oldRecordMap, Map<ID, SObject> newRecordMap){}
    public virtual void afterDelete(List<SObject> oldRecords, Map<ID, SObject> oldRecordMap){}
    public virtual void afterUndelete(List<SObject> newRecords, Map<ID, SObject> newRecordMap){}
    
    //STUBS for override in the extended class
    /*
    //required constructor
    public USYD_TriggerHandlerName(String triggerName) {
    	super(triggerName);
    }
	//implement as required
    public override void beforeInsert(List<SObject> newRecords){}
    public override void beforeUpdate(List<SObject> oldRecords, List<SObject> newRecords, Map<ID, SObject> oldRecordMap, Map<ID, SObject> newRecordMap){}
    public override void beforeDelete(List<SObject> oldRecords, Map<ID, SObject> oldRecordMap){}
    public override void afterInsert(List<SObject> newRecords, Map<ID, SObject> newRecordMap){}
    public override void afterUpdate(List<SObject> oldRecords, List<SObject> newRecords, Map<ID, SObject> oldRecordMap, Map<ID, SObject> newRecordMap){}
    public override void afterDelete(List<SObject> oldRecords, Map<ID, SObject> oldRecordMap){}
    public override void afterUndelete(List<SObject> newRecords, Map<ID, SObject> newRecordMap){}
	*/
    
    //SAMPLE trigger code
    /*
    trigger AccountTrigger on Account (before insert, before update) {
        String triggerName = String.valueOf(this).split(':')[0];
        USYD_TriggerHandlerName handler = new USYD_TriggerHandlerName(triggerName);
        handler.execute();
    }
	*/
    
    public USYD_TriggerHandlerBase(String triggerName) {
        this.triggerName = triggerName;
        this.triggerConfig = USYD_Trigger_Setting__mdt.getInstance(triggerName);
    }
    
    private void Log(String source, String message) {
		if (config!=null && config.Trigger_Handler_Logging__c !=null && config.Trigger_Handler_Logging__c==true) {
            SM_ApplicationLog.addLog(SM_ApplicationLog.LOGGING_LEVEL.INFO.name(), 
                                     message, source, null);                
        }
    }
    
    public void execute() {
        integer triggerSize = trigger.size;
        if (!trigger.isExecuting && !Test.isRunningTest()) return;
        if (!(triggerSize>0) && !Test.isRunningTest()) return;
        
        if (this.isTriggerEnabled()) {
                this.Log('USYD_TriggerHandlerBase.execute()',
                         'Trigger ' + this.triggerName + ' executed for event ' + String.valueOf(Trigger.operationType) + 
                         ' with ' + String.valueOf(triggerSize) + ' records: trigger switch is ON.');               
            this.run(Trigger.operationType);
        } else {
                this.log('USYD_TriggerHandlerBase.execute()',
                         'Trigger ' + this.triggerName + ' NOT executed for event ' + String.valueOf(Trigger.operationType) + 
                         ' with ' + String.valueOf(triggerSize) + ' records: trigger switch is OFF.');            
        }
        SM_ApplicationLog.publishLogs(); 
    }

    public boolean isTriggerEnabled() {
        boolean enabled = false;
        String operation = String.valueOf(trigger.operationType);
        if (operation==null && Test.isRunningTest()) operation = string.valueOf(TEST_DEFAULT_OP);
        
        enabled = allTriggerConfig!=null && (boolean.valueOf(allTriggerConfig.get(operation + '__c'))==true);
        enabled = enabled ? triggerConfig!=null && (boolean.valueOf(triggerConfig.get(operation + '__c'))==true) : false;

        return enabled;
    }       
    
    @testvisible
    private void run(System.TriggerOperation op) {
        if (op==null && Test.isRunningTest()) op = TEST_DEFAULT_OP;
        switch on op {
            when BEFORE_INSERT {
                this.beforeInsert(trigger.new);
            }
            when BEFORE_UPDATE {
                this.beforeUpdate(Trigger.old, Trigger.new, Trigger.oldMap, Trigger.newMap);
            }
            when BEFORE_DELETE {
                this.beforeDelete(Trigger.old, Trigger.oldMap);
            }
            when AFTER_INSERT {
                this.afterInsert(Trigger.new, Trigger.newMap);
            }
            when AFTER_UPDATE {
                this.afterUpdate(Trigger.old, Trigger.new, Trigger.oldMap, Trigger.newMap);
            }
            when AFTER_DELETE {
                this.afterDelete(Trigger.old, Trigger.oldMap);
            }
            when AFTER_UNDELETE {
                this.afterUndelete(Trigger.new, Trigger.newMap);
            }            
        }
    }
}