Added default deploy callback + new Flow input controls (#9)

jongpie · web-flow · commit 508bd495cace · 2021-03-30T17:30:37.000-07:00
* Add default callback + email controls in Flow

* Updated README with details about using custom callbacks

* Removed default picklist value on example picklist field

* Fixed a test that was calling the wrong deploy method overload
diff --git a/README.md b/README.md
@@ -51,3 +51,53 @@ Since Apex can already update custom metadata records (it just can't save the ch
     // Bonus, get the deployment job IDs if you want to monitor them
     List<Id> deploymentJobIds = CustomMetadataSaver.getDeploymentJobIds();
 ```
+
+## Custom Deployment Callback
+
+When deploying metadata through Apex, Salesforce provides the ability to create a callback class using [Metadata.DeployCallback](https://developer.salesforce.com/docs/atlas.en-us.apexcode.meta/apexcode/apex_interface_Metadata_DeployCallback.htm).
+
+### Using the Default Callback
+
+Out-of-the-box, this `CustomMetadataSaver` uses a `private` inner class, `CustomMetadataSaver.DefaultDeployCallback`, when deploying CMDT records. It provides 2 options:
+
+-   `sendEmailOnError` - sends an email to the current user when there are 1 or more deployment errors
+-   `sendEmailOnSuccess` - sends an email to the current user when there are no deployment errors
+
+### Using Your Own Custom Callback
+
+To use your own custom Apex class for the callback, first create your class similar to this example
+
+```java
+public class ExampleCallback implements Metadata.DeployCallback {
+
+    public void handleResult(Metadata.DeployResult result, Metadata.DeployCallbackContext context) {
+        System.debug('ExampleCallback is running!');
+    }
+}
+
+```
+
+Within Apex, you can then pass an instance of your class as a parameter to the method `CustomMetadataSaver.deploy()`
+
+```java
+// Create your CMDT records
+List<CustomMetadataDeployTest__mdt> myCMDTRecords = new List<CustomMetadataDeployTest__mdt>();
+
+CustomMetadataDeployTest__mdt myExampleCMDT = new CustomMetadataDeployTest__mdt();
+myExampleCMDT.MasterLabel = 'My CMDT Record';
+myExampleCMDT.DeveloperName = 'My_CMDT_Record';
+myExampleCMDT.ExampleTextField__c = 'Some value';
+
+myCMDTRecords.add(myExampleCMDT);
+
+// Create an instance of your custom callback class
+ExampleCallback myCustomCallback = new ExampleCallback();
+
+// Pass the CMDT records and your custom callback to CustomMetadataSaver
+CustomMetadataSaver.deploy(myCMDTRecords, myCustomCallback);
+
+```
+
+Within Flow, you can also specify a custom callback class by specifying the Apex class name within the deploy action
+
+![Flow: Deploy with Custom Callback](./content/flow-deploy-with-custom-callback.png)
diff --git a/content/flow-deploy-with-custom-callback.png b/content/flow-deploy-with-custom-callback.png
diff --git a/force-app/main/custom-metadata-saver/classes/CustomMetadataSaver.cls b/force-app/main/custom-metadata-saver/classes/CustomMetadataSaver.cls
@@ -4,12 +4,35 @@
 //----------------------------------------------------------------------------------------------------//
 
 public inherited sharing class CustomMetadataSaver {
+    private static final Boolean DEFAULT_SEND_EMAIL_ON_ERROR = false;
+    private static final Boolean DEFAULT_SEND_EMAIL_ON_SUCCESS = false;
     private static final List<String> DEPLOYMENT_JOB_IDS = new List<String>();
     private static final Set<String> IGNORED_FIELD_NAMES = getIgnoredFieldNames();
 
     public class FlowInput {
-        @InvocableVariable(required=true label='The collection of custom metadata type records to deploy')
+        @InvocableVariable(required=true label='Custom Metadata Type Records to Deploy')
         public List<SObject> customMetadataRecords;
+
+        @InvocableVariable(
+            required=true
+            label='Send Email Alert if the Deployment Fails'
+            description='This option is only used by the default callback Apex class.'
+        )
+        public Boolean sendEmailOnError;
+
+        @InvocableVariable(
+            required=true
+            label='Send Email Alert if the Deployment Succeeds'
+            description='This option is only used by the default callback Apex class.'
+        )
+        public Boolean sendEmailOnSuccess;
+
+        @InvocableVariable(
+            required=false
+            label='(Optional) Custom Callback Apex Class'
+            description='The name of your Apex class to execute after the deployment completes. When provided, this is used instead of the default callback.'
+        )
+        public String customCallbackName;
     }
 
     private CustomMetadataSaver() {
@@ -18,27 +41,49 @@ public inherited sharing class CustomMetadataSaver {
 
     @InvocableMethod(
         category='Custom Metadata'
-        label='Deploy Changes to Custom Metadata Records'
+        label='Deploy Custom Metadata Type Records'
         description='Deploys changes to the list of custom metadata records'
     )
-    public static void deploy(List<FlowInput> inputs) {
+    public static List<String> deploy(List<FlowInput> inputs) {
         System.debug('inputs==' + inputs);
 
-        List<SObject> consolidatedList = new List<SObject>();
+        Boolean sendEmailOnError = DEFAULT_SEND_EMAIL_ON_ERROR;
+        Boolean sendEmailOnSuccess = DEFAULT_SEND_EMAIL_ON_SUCCESS;
+        String customCallbackName;
+
+        // Combine all CMDT records into 1 list so that there is only 1 deployment
+        // TODO allow this to be controlled via FlowInput - there are uses cases for also having multiple deployments
+        List<SObject> consolidatedCustomMetadataRecords = new List<SObject>();
         for (FlowInput input : inputs) {
-            consolidatedList.addAll(input.customMetadataRecords);
+            consolidatedCustomMetadataRecords.addAll(input.customMetadataRecords);
+            // If any of the inputs confirm that an email should be sent, then send it - otherwise, no email will be sent
+            if (input.sendEmailOnError == true) {
+                sendEmailOnError = input.sendEmailOnError;
+            }
+            // If any of the inputs confirm that an email should be sent, then send it - otherwise, no email will be sent
+            if (input.sendEmailOnSuccess == true) {
+                sendEmailOnSuccess = input.sendEmailOnSuccess;
+            }
+            // Assumption: only a single custom callback will be specified
+            // If we find a custom callback class name, update the variable
+            if (String.isNotBlank(input.customCallbackName)) {
+                customCallbackName = input.customCallbackName;
+            }
         }
 
-        System.debug('consolidatedList==' + consolidatedList);
+        System.debug('consolidatedCustomMetadataRecords==' + consolidatedCustomMetadataRecords);
+
+        Metadata.DeployCallback callback = getFlowDeployCallback(customCallbackName, sendEmailOnError, sendEmailOnSuccess);
+        System.debug('callback==' + callback);
 
-        deploy(consolidatedList, null);
+        return new List<String>{ deploy(consolidatedCustomMetadataRecords, callback) };
     }
 
-    public static void deploy(List<SObject> customMetadataRecords) {
-        deploy(customMetadataRecords, null);
+    public static String deploy(List<SObject> customMetadataRecords) {
+        return deploy(customMetadataRecords, new DefaultDeployCallback());
     }
 
-    public static void deploy(List<SObject> customMetadataRecords, Metadata.DeployCallback callback) {
+    public static String deploy(List<SObject> customMetadataRecords, Metadata.DeployCallback callback) {
         Metadata.DeployContainer deployment = new Metadata.DeployContainer();
 
         for (SObject customMetadataRecord : customMetadataRecords) {
@@ -49,6 +94,8 @@ public inherited sharing class CustomMetadataSaver {
         String jobId = Test.isRunningTest() ? 'Fake Job ID' : Metadata.Operations.enqueueDeployment(deployment, callback);
         DEPLOYMENT_JOB_IDS.add(jobId);
         System.debug(LoggingLevel.INFO, 'Deployment Job ID: ' + jobId);
+
+        return jobId;
     }
 
     public static List<String> getDeploymentJobIds() {
@@ -93,4 +140,81 @@ public inherited sharing class CustomMetadataSaver {
 
         return customMetadata;
     }
+
+    private static Metadata.DeployCallback getFlowDeployCallback(String customCallbackName, Boolean sendEmailOnError, Boolean sendEmailOnSuccess) {
+        Metadata.DeployCallback callback;
+        if (String.isNotBlank(customCallbackName) && Type.forName(customCallbackName) != null) {
+            // Dynamically create a new instance of the specified class
+            // Assumption: specified class uses a parameterless constructor
+            System.debug('customCallbackName==' + customCallbackName);
+            callback = (Metadata.DeployCallback) Type.forName(customCallbackName).newInstance();
+        } else {
+            // If no custom callback class is specified, use the default inner class
+            callback = new DefaultDeployCallback(sendEmailOnError, sendEmailOnSuccess);
+        }
+        return callback;
+    }
+
+    private static void sendEmail(String subject, String textBody) {
+        Messaging.SingleEmailMessage singleEmail = new Messaging.SingleEmailMessage();
+        singleEmail.setToAddresses(new List<String>{ UserInfo.getUserEmail() });
+        singleEmail.setSubject(subject);
+        singleEmail.setPlainTextBody(textBody);
+
+        Messaging.sendEmail(new List<Messaging.SingleEmailMessage>{ singleEmail });
+    }
+
+    // Inner class used as the default callback if no other callback is specified
+    @testVisible
+    private class DefaultDeployCallback implements Metadata.DeployCallback {
+        @testVisible
+        private Boolean success;
+
+        private Boolean sendEmailOnError;
+        private Boolean sendEmailOnSuccess;
+
+        @testVisible
+        private DefaultDeployCallback() {
+            this(DEFAULT_SEND_EMAIL_ON_ERROR, DEFAULT_SEND_EMAIL_ON_SUCCESS);
+        }
+        @testVisible
+        private DefaultDeployCallback(Boolean sendEmailOnError, Boolean sendEmailOnSuccess) {
+            this.sendEmailOnError = sendEmailOnError;
+            this.sendEmailOnSuccess = sendEmailOnSuccess;
+        }
+
+        public void handleResult(Metadata.DeployResult result, Metadata.DeployCallbackContext context) {
+            System.debug('deploy result.success==' + result.success);
+            System.debug('deploy result==' + result);
+            System.debug('deploy callback context==' + context);
+
+            System.debug('this.sendEmailOnError==' + this.sendEmailOnError);
+            System.debug('this.sendEmailOnSuccess==' + this.sendEmailOnSuccess);
+
+            this.success = result.success;
+
+            // Build the email pieces
+            String subject = 'Custom metadata type deployment completed';
+            String textBody = 'Deployment ID {0} completed\nStatus: {1}\n{2} total items deployed\n{3} items failed\nDetails: {4}';
+            List<Object> textReplacements = new List<Object>{
+                result.id,
+                result.status,
+                result.numberComponentsTotal,
+                result.numberComponentErrors,
+                Json.serializePretty(result.details)
+            };
+            textBody = String.format(textBody, textReplacements);
+
+            // Send the email
+            if (result.success == true && this.sendEmailOnSuccess == true) {
+                System.debug('Deployment Succeeded!');
+
+                sendEmail(subject, textBody);
+            } else if (result.success == false && this.sendEmailOnError == true) {
+                System.debug('Deployment Failed!');
+
+                sendEmail(subject, textBody);
+            }
+        }
+    }
 }
diff --git a/force-app/tests/custom-metadata-saver/classes/CustomMetadataSaver_Tests.cls b/force-app/tests/custom-metadata-saver/classes/CustomMetadataSaver_Tests.cls
@@ -41,16 +41,64 @@ private class CustomMetadataSaver_Tests {
         List<CustomMetadataDeployTest__mdt> cdmtRecords = new List<CustomMetadataDeployTest__mdt>{ cmdtRecord };
         CustomMetadataSaver.FlowInput input = new CustomMetadataSaver.FlowInput();
         input.customMetadataRecords = cdmtRecords;
+        input.sendEmailOnError = true;
+        input.sendEmailOnSuccess = true;
 
         List<CustomMetadataSaver.FlowInput> inputs = new List<CustomMetadataSaver.FlowInput>();
         inputs.add(input);
 
         System.assertEquals(1, cdmtRecords.size());
 
         Test.startTest();
-        CustomMetadataSaver.deploy(cdmtRecords);
+        CustomMetadataSaver.deploy(inputs);
         Test.stopTest();
 
         System.assertEquals(1, CustomMetadataSaver.getDeploymentJobIds().size());
     }
+
+    @isTest
+    static void it_should_handle_deploy_success() {
+        // Instantiate the callback.
+        Boolean sendEmailOnError = true;
+        Boolean sendEmailOnSuccess = true;
+        CustomMetadataSaver.DefaultDeployCallback callback = new CustomMetadataSaver.DefaultDeployCallback(sendEmailOnError, sendEmailOnSuccess);
+
+        // Create test result and context objects.
+        Metadata.DeployResult result = new Metadata.DeployResult();
+        result.success = true;
+        result.numberComponentsTotal = 5;
+        result.numberComponentErrors = 0;
+        Metadata.DeployCallbackContext context = new Metadata.DeployCallbackContext();
+
+        System.assertEquals(null, callback.success);
+
+        Test.startTest();
+        callback.handleResult(result, context);
+        Test.stopTest();
+
+        System.assertEquals(true, callback.success);
+    }
+
+    @isTest
+    static void it_should_handle_deploy_error() {
+        // Instantiate the callback
+        Boolean sendEmailOnError = true;
+        Boolean sendEmailOnSuccess = true;
+        CustomMetadataSaver.DefaultDeployCallback callback = new CustomMetadataSaver.DefaultDeployCallback(sendEmailOnError, sendEmailOnSuccess);
+
+        // Setup the deploy result and context objects
+        Metadata.DeployResult result = new Metadata.DeployResult();
+        result.success = false;
+        result.numberComponentsTotal = 5;
+        result.numberComponentErrors = 2;
+        Metadata.DeployCallbackContext context = new Metadata.DeployCallbackContext();
+
+        System.assertEquals(null, callback.success);
+
+        Test.startTest();
+        callback.handleResult(result, context);
+        Test.stopTest();
+
+        System.assertEquals(false, callback.success);
+    }
 }
diff --git a/force-app/tests/custom-metadata-saver/objects/CustomMetadataDeployTest__mdt/fields/ExamplePicklistField__c.field-meta.xml b/force-app/tests/custom-metadata-saver/objects/CustomMetadataDeployTest__mdt/fields/ExamplePicklistField__c.field-meta.xml
@@ -12,7 +12,7 @@
             <sorted>false</sorted>
             <value>
                 <fullName>Option 1</fullName>
-                <default>true</default>
+                <default>false</default>
                 <label>Option 1</label>
             </value>
             <value>
