mcdev 5.0.1 → 5.1.0

package/lib/metadataTypes/Automation.js

@@ -6,6 +6,7 @@ const Util = require('../util/util');
 const File = require('../util/file');
 const Definitions = require('../MetadataTypeDefinitions');
 const cache = require('../util/cache');
+const pLimit = require('p-limit');
 
 /**
  * Automation MetadataType
@@ -13,6 +14,7 @@ const cache = require('../util/cache');
  * @augments MetadataType
  */
 class Automation extends MetadataType {
+    static notificationUpdates = {};
     /**
      * Retrieves Metadata of Automation
      *
@@ -35,11 +37,13 @@ class Automation extends MetadataType {
             };
         }
         const results = await this.client.soap.retrieveBulk('Program', ['ObjectID'], requestParams);
-        if (results.Results?.length) {
+        if (results.Results?.length && !key) {
             // empty results will come back without "Results" defined
             Util.logger.info(
                 Util.getGrayMsg(
-                    ` - ${results.Results?.length} Automations found. Retrieving details...`
+                    ` - ${results.Results?.length} automation${
+                        results.Results?.length === 1 ? '' : 's'
+                    } found. Retrieving details...`
                 )
             );
         }
@@ -70,19 +74,96 @@ class Automation extends MetadataType {
                   })
               )
             : [];
-        const parsed = this.parseResponseBody({ items: details });
+        let metadataMap = this.parseResponseBody({ items: details });
+
+        if (Object.keys(metadataMap).length) {
+            // attach notification information to each automation that has any
+            await this.#getAutomationNotificationsREST(metadataMap);
+        }
+
+        // * retrieveDir can be empty when we use it in the context of postDeployTasks
+        if (retrieveDir) {
+            metadataMap = await this.saveResults(metadataMap, retrieveDir, null, null);
+            Util.logger.info(
+                `Downloaded: ${this.definition.type} (${Object.keys(metadataMap).length})` +
+                    Util.getKeysString(key)
+            );
+
+            await this.runDocumentOnRetrieve(key, metadataMap);
+        }
+        return { metadata: metadataMap, type: this.definition.type };
+    }
+
+    /**
+     * helper for {@link Automation.retrieve} to get Automation Notifications
+     *
+     * @private
+     * @param {TYPE.MetadataTypeMap} metadataMap keyField => metadata map
+     * @returns {Promise.<void>} Promise of nothing
+     */
+    static async #getAutomationNotificationsREST(metadataMap) {
+        Util.logger.info(Util.getGrayMsg(` Retrieving Automation Notification information...`));
+
+        // get list of keys that we retrieved so far
+        const foundKeys = Object.keys(metadataMap);
 
-        // * retrieveDir is mandatory in this method as it is not used for caching (there is a seperate method for that)
-        const savedMetadata = await this.saveResults(parsed, retrieveDir, null, null);
+        // get encodedAutomationID to retrieve notification information
+        const iteratorBackup = this.definition.bodyIteratorField;
+        this.definition.bodyIteratorField = 'entry';
+        const automationLegacyMapObj = await super.retrieveREST(
+            undefined,
+            `/legacy/v1/beta/bulk/automations/automation/definition/`
+        );
+        this.definition.bodyIteratorField = iteratorBackup;
+        const automationLegacyMap = Object.keys(automationLegacyMapObj.metadata)
+            .filter((key) => foundKeys.includes(key))
+            // ! using the `id` field to retrieve notifications does not work. instead one needs to use the URL in the `notifications` field
+            .map((key) => ({
+                id: automationLegacyMapObj.metadata[key].id,
+                key,
+            }));
+
+        // get notifications for each automation
+        const rateLimit = pLimit(5);
+        let found = 0;
+        let skipped = 0;
+        const promiseMap = await Promise.all(
+            automationLegacyMap.map((automationLegacy) =>
+                rateLimit(async () => {
+                    // this is a file so extended is at another endpoint
+                    try {
+                        const notificationsResult = await this.client.rest.get(
+                            '/legacy/v1/beta/automations/notifications/' + automationLegacy.id
+                        );
+                        if (Array.isArray(notificationsResult?.workers)) {
+                            metadataMap[automationLegacy.key].notifications =
+                                notificationsResult.workers.map((n) => ({
+                                    email: n.definition.split(',').map((item) => item.trim()),
+                                    message: n.body,
+                                    type: n.notificationType,
+                                }));
+                            found++;
+                        } else {
+                            throw new TypeError(JSON.stringify(notificationsResult));
+                        }
+                    } catch (ex) {
+                        Util.logger.debug(
+                            ` ☇ skipping Notifications for Automation ${automationLegacy.key}: ${ex.message} ${ex.code}`
+                        );
+                        skipped++;
+                    }
+                })
+            )
+        );
         Util.logger.info(
-            `Downloaded: ${this.definition.type} (${Object.keys(savedMetadata).length})` +
-                Util.getKeysString(key)
+            Util.getGrayMsg(` Notifications found for ${found} automation${found === 1 ? '' : 's'}`)
         );
-        if (this.properties.metaDataTypes.documentOnRetrieve.includes(this.definition.type)) {
-            await this.document(savedMetadata);
-        }
-        return { metadata: savedMetadata, type: this.definition.type };
+        Util.logger.debug(
+            `Notifications not found for ${skipped} automation${skipped === 1 ? '' : 's'}`
+        );
+        return promiseMap;
     }
+
     /**
      * Retrieves Metadata of Automation
      *
@@ -134,6 +215,7 @@ class Automation extends MetadataType {
      * @returns {Promise.<TYPE.AutomationMapObj>} Promise of metadata
      */
     static async retrieveForCache() {
+        // get automations for cache
         const results = await this.client.soap.retrieveBulk('Program', [
             'ObjectID',
             'CustomerKey',
@@ -141,14 +223,29 @@ class Automation extends MetadataType {
         ]);
         const resultsConverted = {};
         if (Array.isArray(results?.Results)) {
+            // get encodedAutomationID to retrieve notification information
+            const keyBackup = this.definition.keyField;
+            const iteratorBackup = this.definition.bodyIteratorField;
+            this.definition.keyField = 'key';
+            this.definition.bodyIteratorField = 'entry';
+            const automationsLegacy = await super.retrieveREST(
+                undefined,
+                `/legacy/v1/beta/bulk/automations/automation/definition/`
+            );
+            this.definition.keyField = keyBackup;
+            this.definition.bodyIteratorField = iteratorBackup;
+
+            // merge encodedAutomationID into results
             for (const m of results.Results) {
                 resultsConverted[m.CustomerKey] = {
                     id: m.ObjectID,
                     key: m.CustomerKey,
                     name: m.Name,
+                    programId: automationsLegacy.metadata[m.CustomerKey]?.id,
                 };
             }
         }
+
         return { metadata: resultsConverted, type: this.definition.type };
     }
 
@@ -175,14 +272,21 @@ class Automation extends MetadataType {
                 Util.logger.error(`${this.definition.type} '${name}' not found on server.`);
                 return;
             }
-            const details = await this.client.rest.get(
+            let details = await this.client.rest.get(
                 '/automation/v1/automations/' + metadata.ObjectID
             );
+            const metadataMap = this.parseResponseBody({ items: [details] });
+            if (Object.keys(metadataMap).length) {
+                // attach notification information to each automation that has any
+                await this.#getAutomationNotificationsREST(metadataMap);
+                details = Object.values(metadataMap)[0];
+            }
+
             let val = null;
             let originalKey;
             // if parsing fails, we should just save what we get
             try {
-                const parsedDetails = this.parseMetadata(details);
+                const parsedDetails = this.postRetrieveTasks(details);
                 originalKey = parsedDetails[this.definition.keyField];
                 if (parsedDetails !== null) {
                     val = JSON.parse(
@@ -218,10 +322,128 @@ class Automation extends MetadataType {
      * manages post retrieve steps
      *
      * @param {TYPE.AutomationItem} metadata a single automation
-     * @returns {TYPE.AutomationItem} metadata
+     * @returns {TYPE.AutomationItem | void} parsed item
      */
     static postRetrieveTasks(metadata) {
-        return this.parseMetadata(metadata);
+        // folder
+        this.setFolderPath(metadata);
+        // automations are often skipped due to lack of support.
+        try {
+            if (metadata.type === 'scheduled' && metadata.schedule?.startDate) {
+                // Starting Source == 'Schedule'
+
+                try {
+                    if (this.definition.timeZoneMapping[metadata.schedule.timezoneName]) {
+                        // if we found the id in our list, remove the redundant data
+                        delete metadata.schedule.timezoneId;
+                    }
+                } catch {
+                    Util.logger.debug(
+                        `- Schedule name '${metadata.schedule.timezoneName}' not found in definition.timeZoneMapping`
+                    );
+                }
+                try {
+                    // type 'Running' is temporary status only, overwrite with Scheduled for storage.
+                    if (metadata.type === 'scheduled' && metadata.status === 'Running') {
+                        metadata.status = 'Scheduled';
+                    }
+                } catch {
+                    Util.logger.error(
+                        `- ${this.definition.type} ${metadata.name} does not have a valid schedule setting.`
+                    );
+                    return;
+                }
+            } else if (metadata.type === 'triggered' && metadata.fileTrigger) {
+                // Starting Source == 'File Drop'
+                // Do nothing for now
+            }
+            if (metadata.steps) {
+                for (const step of metadata.steps) {
+                    const stepNumber = step.stepNumber || step.step;
+                    delete step.stepNumber;
+                    delete step.step;
+
+                    for (const activity of step.activities) {
+                        try {
+                            // get metadata type of activity
+                            activity.r__type = Util.inverseGet(
+                                this.definition.activityTypeMapping,
+                                activity.objectTypeId
+                            );
+                            delete activity.objectTypeId;
+                        } catch {
+                            Util.logger.warn(
+                                ` - Unknown activity type '${activity.objectTypeId}'` +
+                                    ` in step ${stepNumber}.${activity.displayOrder}` +
+                                    ` of Automation '${metadata.name}'`
+                            );
+                            continue;
+                        }
+
+                        // if no activityObjectId then either serialized activity
+                        // (config in Automation ) or unconfigured so no further action to be taken
+                        if (
+                            activity.activityObjectId === '00000000-0000-0000-0000-000000000000' ||
+                            activity.activityObjectId == null
+                        ) {
+                            Util.logger.debug(
+                                ` - skip parsing of activity due to missing activityObjectId: ${JSON.stringify(
+                                    activity
+                                )}`
+                            );
+                            // empty if block
+                        } else if (!this.definition.dependencies.includes(activity.r__type)) {
+                            Util.logger.debug(
+                                ` - skip parsing because the type is not set up as a dependecy for ${this.definition.type}`
+                            );
+                        }
+                        // / if managed by cache we can update references to support deployment
+                        else if (
+                            Definitions[activity.r__type]?.['idField'] &&
+                            cache.getCache(this.buObject.mid)[activity.r__type]
+                        ) {
+                            try {
+                                // this will override the name returned by the API in case this activity's name was changed since the automation was last updated, keeping things nicely in sync for mcdev
+                                const name = cache.searchForField(
+                                    activity.r__type,
+                                    activity.activityObjectId,
+                                    Definitions[activity.r__type].idField,
+                                    Definitions[activity.r__type].nameField
+                                );
+                                if (name !== activity.name) {
+                                    Util.logger.debug(
+                                        ` - updated name of step ${stepNumber}.${activity.displayOrder}` +
+                                            ` in Automation '${metadata.name}' from ${activity.name} to ${name}`
+                                    );
+                                    activity.name = name;
+                                }
+                            } catch (ex) {
+                                // getFromCache throws error where the dependent metadata is not found
+                                Util.logger.warn(
+                                    ` - Missing ${activity.r__type} activity '${activity.name}'` +
+                                        ` in step ${stepNumber}.${activity.displayOrder}` +
+                                        ` of Automation '${metadata.name}' (${ex.message})`
+                                );
+                            }
+                        } else {
+                            Util.logger.warn(
+                                ` - Missing ${activity.r__type} activity '${activity.name}'` +
+                                    ` in step ${stepNumber}.${activity.displayOrder}` +
+                                    ` of Automation '${metadata.name}' (Not Found in Cache)`
+                            );
+                        }
+                    }
+                }
+            }
+            return JSON.parse(JSON.stringify(metadata));
+        } catch (ex) {
+            Util.logger.warn(
+                ` - ${this.definition.typeName} '${metadata[this.definition.nameField]}': ${
+                    ex.message
+                }`
+            );
+            return null;
+        }
     }
 
     /**
@@ -235,7 +457,15 @@ class Automation extends MetadataType {
      */
     static async deploy(metadata, targetBU, retrieveDir, isRefresh) {
         const upsertResults = await this.upsert(metadata, targetBU, isRefresh);
-        await this.saveResults(upsertResults, retrieveDir, null);
+        const savedMetadata = await this.saveResults(upsertResults, retrieveDir, null);
+        if (
+            this.properties.metaDataTypes.documentOnRetrieve.includes(this.definition.type) &&
+            !this.definition.documentInOneFile
+        ) {
+            const count = Object.keys(savedMetadata).length;
+            Util.logger.debug(` - Running document for ${count} record${count === 1 ? '' : 's'}`);
+            await this.document(savedMetadata);
+        }
         return upsertResults;
     }
 
@@ -270,6 +500,15 @@ class Automation extends MetadataType {
      * @returns {Promise.<TYPE.AutomationItem>} Promise
      */
     static async preDeployTasks(metadata) {
+        if (metadata.notifications) {
+            this.notificationUpdates[metadata.key] = metadata.notifications;
+        } else {
+            const cached = cache.getByKey(metadata.key);
+            if (cached?.notifications) {
+                // if notifications existed but are no longer present in the deployment package, we need to run an empty update call to remove them
+                this.notificationUpdates[metadata.key] = [];
+            }
+        }
         if (this.validateDeployMetadata(metadata)) {
             // folder
             this.setFolderId(metadata);
@@ -397,82 +636,153 @@ class Automation extends MetadataType {
     /**
      * Gets executed after deployment of metadata type
      *
-     * @param {TYPE.AutomationMap} metadata metadata mapped by their keyField
-     * @param {TYPE.AutomationMap} originalMetadata metadata to be updated (contains additioanl fields)
+     * @param {TYPE.AutomationMap} metadataMap metadata mapped by their keyField
+     * @param {TYPE.AutomationMap} originalMetadataMap metadata to be updated (contains additioanl fields)
      * @returns {Promise.<void>} -
      */
-    static async postDeployTasks(metadata, originalMetadata) {
-        for (const key in metadata) {
+    static async postDeployTasks(metadataMap, originalMetadataMap) {
+        for (const key in metadataMap) {
             // need to put schedule on here if status is scheduled
+            await Automation.#scheduleAutomation(metadataMap, originalMetadataMap, key);
 
-            if (originalMetadata[key]?.type === 'scheduled') {
-                // Starting Source == 'Schedule': Try starting the automation
-                if (originalMetadata[key].status === 'Scheduled') {
-                    let schedule = null;
+            // need to update notifications separately if there are any
+            await Automation.#updateNotificationInfoREST(metadataMap, key);
+
+            // rewrite upsert to retrieve fields
+            const metadata = metadataMap[key];
+            if (metadata.steps) {
+                for (const step of metadata.steps) {
+                    step.name = step.annotation;
+                    delete step.annotation;
+                }
+            }
+        }
+    }
+    /**
+     * helper for {@link Automation.postDeployTasks}
+     *
+     * @param {TYPE.AutomationMap} metadataMap metadata mapped by their keyField
+     * @param {string} key current customer key
+     * @returns {Promise.<void>} -
+     */
+    static async #updateNotificationInfoREST(metadataMap, key) {
+        if (this.notificationUpdates[key]) {
+            // create & update automation calls return programId as 'legacyId'; retrieve does not return it
+            const programId = metadataMap[key]?.legacyId;
+            if (programId) {
+                const notificationBody = {
+                    programId,
+                    workers: this.notificationUpdates[key].map((notification) => ({
+                        programId,
+                        notificationType: notification.type,
+                        definition: Array.isArray(notification.email)
+                            ? notification.email.join(',')
+                            : notification.email,
+                        body: notification.message,
+                        channelType: 'Account',
+                    })),
+                };
+                try {
+                    const result = await this.client.rest.post(
+                        '/legacy/v1/beta/automations/notifications/' + programId,
+                        notificationBody
+                    );
+                    if (result) {
+                        // should be empty if all OK
+                        throw new Error(result);
+                    }
+                } catch (ex) {
+                    Util.logger.error(
+                        `Error updating notifications for automation '${metadataMap[key].name}': ${ex.message} (${ex.code}))`
+                    );
+                }
+                Util.logger.info(
+                    Util.getGrayMsg(
+                        ` - updated notifications for automation '${metadataMap[key].name}'`
+                    )
+                );
+            }
+        }
+    }
+
+    /**
+     * helper for {@link postDeployTasks}
+     *
+     * @param {TYPE.AutomationMap} metadataMap metadata mapped by their keyField
+     * @param {TYPE.AutomationMap} originalMetadataMap metadata to be updated (contains additioanl fields)
+     * @param {string} key current customer key
+     */
+    static async #scheduleAutomation(metadataMap, originalMetadataMap, key) {
+        if (originalMetadataMap[key]?.type === 'scheduled') {
+            // Starting Source == 'Schedule': Try starting the automation
+            if (originalMetadataMap[key].status === 'Scheduled') {
+                let schedule = null;
+                try {
+                    schedule = this._buildSchedule(originalMetadataMap[key].schedule);
+                } catch (ex) {
+                    Util.logger.error(
+                        `- Could not create schedule for automation '${originalMetadataMap[key].name}' to start it: ${ex.message}`
+                    );
+                }
+                if (schedule !== null) {
                     try {
-                        schedule = this._buildSchedule(originalMetadata[key].schedule);
+                        // remove the fields that are not needed for the schedule but only for CLI output
+                        const schedule_StartDateTime = schedule._StartDateTime;
+                        delete schedule._StartDateTime;
+                        const schedule_interval = schedule._interval;
+                        delete schedule._interval;
+                        const schedule_timezoneString = schedule._timezoneString;
+                        delete schedule._timezoneString;
+                        // start the automation
+                        await this.client.soap.schedule(
+                            'Automation',
+                            schedule,
+                            {
+                                Interaction: {
+                                    ObjectID: metadataMap[key].id,
+                                },
+                            },
+                            'start',
+                            {}
+                        );
+                        const intervalString =
+                            (schedule_interval > 1 ? `${schedule_interval} ` : '') +
+                            (schedule.RecurrenceType === 'Daily'
+                                ? 'Day'
+                                : schedule.RecurrenceType.slice(0, -2) +
+                                  (schedule_interval > 1 ? 's' : ''));
+                        Util.logger.warn(
+                            ` - scheduled automation '${
+                                originalMetadataMap[key].name
+                            }' deployed as Active: runs every ${intervalString} starting ${
+                                schedule_StartDateTime.split('T').join(' ').split('.')[0]
+                            } ${schedule_timezoneString}`
+                        );
                     } catch (ex) {
                         Util.logger.error(
-                            `- Could not create schedule for automation ${originalMetadata[key].name} to start it: ${ex.message}`
+                            `- Could not start scheduled automation '${originalMetadataMap[key].name}': ${ex.message}`
                         );
                     }
-                    if (schedule !== null) {
-                        try {
-                            // remove the fields that are not needed for the schedule but only for CLI output
-                            const schedule_StartDateTime = schedule._StartDateTime;
-                            delete schedule._StartDateTime;
-                            const schedule_interval = schedule._interval;
-                            delete schedule._interval;
-                            const schedule_timezoneString = schedule._timezoneString;
-                            delete schedule._timezoneString;
-                            // start the automation
-                            await this.client.soap.schedule(
-                                'Automation',
-                                schedule,
-                                {
-                                    Interaction: {
-                                        ObjectID: metadata[key].id,
-                                    },
-                                },
-                                'start',
-                                {}
-                            );
-                            const intervalString =
-                                (schedule_interval > 1 ? `${schedule_interval} ` : '') +
-                                (schedule.RecurrenceType === 'Daily'
-                                    ? 'Day'
-                                    : schedule.RecurrenceType.slice(0, -2) +
-                                      (schedule_interval > 1 ? 's' : ''));
-                            Util.logger.warn(
-                                ` - scheduled automation '${
-                                    originalMetadata[key].name
-                                }' deployed Active: runs every ${intervalString} starting ${
-                                    schedule_StartDateTime.split('T').join(' ').split('.')[0]
-                                } ${schedule_timezoneString}`
-                            );
-                        } catch (ex) {
-                            Util.logger.error(
-                                `- Could not start scheduled automation '${originalMetadata[key].name}': ${ex.message}`
-                            );
-                        }
-                    }
-                } else {
-                    Util.logger.warn(
-                        ` - scheduled automation '${originalMetadata[key].name}' deployed Paused`
-                    );
                 }
+            } else {
+                Util.logger.info(
+                    Util.getGrayMsg(
+                        ` - scheduled automation '${originalMetadataMap[key].name}' deployed as Paused`
+                    )
+                );
             }
-            if (metadata[key].startSource) {
-                metadata[key].schedule = metadata[key].startSource.schedule;
+        }
+        if (metadataMap[key].startSource) {
+            metadataMap[key].schedule = metadataMap[key].startSource.schedule;
 
-                delete metadata[key].startSource;
-            }
-            if (metadata[key].schedule) {
-                metadata[key].schedule.typeId = metadata[key].schedule.scheduleTypeId;
-                delete metadata[key].schedule.scheduleTypeId;
-            }
+            delete metadataMap[key].startSource;
+        }
+        if (metadataMap[key].schedule?.scheduleTypeId) {
+            metadataMap[key].schedule.typeId = metadataMap[key].schedule.scheduleTypeId;
+            delete metadataMap[key].schedule.scheduleTypeId;
         }
     }
+
     /**
      * generic script that retrieves the folder path from cache and updates the given metadata with it after retrieve
      *
@@ -538,118 +848,6 @@ class Automation extends MetadataType {
         }
     }
 
-    /**
-     * parses retrieved Metadata before saving
-     *
-     * @param {TYPE.AutomationItem} metadata a single automation definition
-     * @returns {TYPE.AutomationItem | void} parsed item
-     */
-    static parseMetadata(metadata) {
-        // folder
-        this.setFolderPath(metadata);
-        // automations are often skipped due to lack of support.
-        try {
-            if (metadata.type === 'scheduled' && metadata.schedule?.startDate) {
-                // Starting Source == 'Schedule'
-
-                try {
-                    if (this.definition.timeZoneMapping[metadata.schedule.timezoneName]) {
-                        // if we found the id in our list, remove the redundant data
-                        delete metadata.schedule.timezoneId;
-                    }
-                } catch {
-                    Util.logger.debug(
-                        `- Schedule name '${metadata.schedule.timezoneName}' not found in definition.timeZoneMapping`
-                    );
-                }
-                try {
-                    // type 'Running' is temporary status only, overwrite with Scheduled for storage.
-                    if (metadata.type === 'scheduled' && metadata.status === 'Running') {
-                        metadata.status = 'Scheduled';
-                    }
-                } catch {
-                    Util.logger.error(
-                        `- ${this.definition.type} ${metadata.name} does not have a valid schedule setting.`
-                    );
-                    return;
-                }
-            } else if (metadata.type === 'triggered' && metadata.fileTrigger) {
-                // Starting Source == 'File Drop'
-                // Do nothing for now
-            }
-            if (metadata.steps) {
-                for (const step of metadata.steps) {
-                    const stepNumber = step.stepNumber || step.step;
-                    delete step.stepNumber;
-                    delete step.step;
-
-                    for (const activity of step.activities) {
-                        try {
-                            // get metadata type of activity
-                            activity.r__type = Util.inverseGet(
-                                this.definition.activityTypeMapping,
-                                activity.objectTypeId
-                            );
-                            delete activity.objectTypeId;
-                        } catch {
-                            Util.logger.warn(
-                                ` - Unknown activity type '${activity.objectTypeId}'` +
-                                    ` in step ${stepNumber}.${activity.displayOrder}` +
-                                    ` of Automation '${metadata.name}'`
-                            );
-                            continue;
-                        }
-
-                        // if no activityObjectId then either serialized activity
-                        // (config in Automation ) or unconfigured so no further action to be taken
-                        if (
-                            activity.activityObjectId === '00000000-0000-0000-0000-000000000000' ||
-                            activity.activityObjectId == null ||
-                            !this.definition.dependencies.includes(activity.r__type)
-                        ) {
-                            // empty if block
-                        }
-                        // / if managed by cache we can update references to support deployment
-                        else if (
-                            Definitions[activity.r__type]?.['idField'] &&
-                            cache.getCache(this.buObject.mid)[activity.r__type]
-                        ) {
-                            try {
-                                activity.activityObjectId = cache.searchForField(
-                                    activity.r__type,
-                                    activity.activityObjectId,
-                                    Definitions[activity.r__type].idField,
-                                    Definitions[activity.r__type].nameField
-                                );
-                            } catch (ex) {
-                                // getFromCache throws error where the dependent metadata is not found
-                                Util.logger.warn(
-                                    ` - Missing ${activity.r__type} activity '${activity.name}'` +
-                                        ` in step ${stepNumber}.${activity.displayOrder}` +
-                                        ` of Automation '${metadata.name}' (${ex.message})`
-                                );
-                            }
-                        } else {
-                            Util.logger.warn(
-                                ` - Missing ${activity.r__type} activity '${activity.name}'` +
-                                    ` in step ${stepNumber}.${activity.displayOrder}` +
-                                    ` of Automation '${metadata.name}' (Not Found in Cache)`
-                            );
-                        }
-                    }
-                }
-            }
-            return JSON.parse(JSON.stringify(metadata));
-        } catch (ex) {
-            Util.logger.warn(
-                ` - ${this.definition.typeName} '${metadata[this.definition.nameField]}': ${
-                    ex.message
-                }`
-            );
-            return null;
-        }
-    }
-
     /**
      * Builds a schedule object to be used for scheduling an automation
      * based on combination of ical string and start/end dates.
@@ -857,6 +1055,27 @@ class Automation extends MetadataType {
             output += `* Pattern: ${json.fileTrigger.fileNamingPattern}\n`;
             output += `* Folder:  ${json.fileTrigger.folderLocationText}\n`;
         }
+        // add empty line to ensure the following notifications are rendered properly
+        output += '\n';
+        if (json.notifications?.length) {
+            output += `**Notifications:**\n\n`;
+            // ensure notifications are sorted by type regardless of how the API returns it
+            const notifications = {};
+            for (const n of json.notifications) {
+                notifications[n.type] =
+                    (Array.isArray(n.email) ? n.email.join(',') : n.email) +
+                    (n.message ? ` ("${n.message}")` : '');
+            }
+            if (notifications.Complete) {
+                output += `* Complete: ${notifications.Complete}\n`;
+            }
+            if (notifications.Error) {
+                output += `* Error: ${notifications.Error}\n`;
+            }
+        } else {
+            output += `**Notifications:** _none_\n\n`;
+        }
+
         // show table with automation steps
         if (tabled && tabled.length) {
             // add empty line to ensure the following table is rendered properly
@@ -964,11 +1183,10 @@ class Automation extends MetadataType {
                 // as part of retrieve & manual execution we could face an empty folder
                 return;
             }
-            await Promise.all(
-                Object.keys(metadata).map((key) => {
-                    this._writeDoc(docPath + '/', key, metadata[key], 'md');
-                    return metadata[key];
-                })
+            return await Promise.all(
+                Object.keys(metadata).map((key) =>
+                    this._writeDoc(docPath + '/', key, metadata[key], 'md')
+                )
             );
         }
     }