mcdev 5.1.0 → 5.2.0

package/lib/metadataTypes/Automation.js

@@ -47,34 +47,41 @@ class Automation extends MetadataType {
                 )
             );
         }
+        // the API seems to handle 50 concurrent requests nicely
+        const rateLimit = pLimit(50);
+
         const details = results.Results
             ? await Promise.all(
-                  results.Results.map(async (a) => {
-                      try {
-                          return await this.client.rest.get(
-                              '/automation/v1/automations/' + a.ObjectID
-                          );
-                      } catch (ex) {
+                  results.Results.map(async (item) =>
+                      rateLimit(async () => {
                           try {
-                              if (ex.message == 'socket hang up') {
-                                  // one more retry; it's a rare case but retrying again should solve the issue gracefully
-                                  return await this.client.rest.get(
-                                      '/automation/v1/automations/' + a.ObjectID
-                                  );
+                              return await this.client.rest.get(
+                                  '/automation/v1/automations/' + item.ObjectID
+                              );
+                          } catch (ex) {
+                              try {
+                                  if (ex.message == 'socket hang up') {
+                                      // one more retry; it's a rare case but retrying again should solve the issue gracefully
+                                      return await this.client.rest.get(
+                                          '/automation/v1/automations/' + item.ObjectID
+                                      );
+                                  }
+                              } catch {
+                                  // no extra action needed, handled below
                               }
-                          } catch {
-                              // no extra action needed, handled below
+                              // if we do get here, we should log the error and continue instead of failing to download all automations
+                              Util.logger.error(
+                                  ` ☇ skipping Automation ${item.ObjectID}: ${ex.message} ${ex.code}`
+                              );
+                              return null;
                           }
-                          // if we do get here, we should log the error and continue instead of failing to download all automations
-                          Util.logger.error(
-                              ` ☇ skipping Automation ${a.ObjectID}: ${ex.message} ${ex.code}`
-                          );
-                          return null;
-                      }
-                  })
+                      })
+                  )
               )
             : [];
-        let metadataMap = this.parseResponseBody({ items: details });
+
+        // * if retrieving some automations fails, a null element would remain in the details-array for each of them that needs to be filtered to prevent it from causing issues elsewhere
+        let metadataMap = this.parseResponseBody({ items: details.filter(Boolean) });
 
         if (Object.keys(metadataMap).length) {
             // attach notification information to each automation that has any
@@ -144,11 +151,19 @@ class Automation extends MetadataType {
                                 }));
                             found++;
                         } else {
-                            throw new TypeError(JSON.stringify(notificationsResult));
+                            if (
+                                !notificationsResult ||
+                                typeof notificationsResult !== 'object' ||
+                                Object.keys(notificationsResult).length !== 1 ||
+                                !notificationsResult?.programId
+                            ) {
+                                throw new TypeError(JSON.stringify(notificationsResult));
+                            }
+                            // * if there are no automation notifications, the API returns a single object with the programId
                         }
                     } catch (ex) {
                         Util.logger.debug(
-                            ` ☇ skipping Notifications for Automation ${automationLegacy.key}: ${ex.message} ${ex.code}`
+                            ` ☇ issue retrieving Notifications for automation ${automationLegacy.key}: ${ex.message} ${ex.code}`
                         );
                         skipped++;
                     }
@@ -242,6 +257,7 @@ class Automation extends MetadataType {
                     key: m.CustomerKey,
                     name: m.Name,
                     programId: automationsLegacy.metadata[m.CustomerKey]?.id,
+                    status: automationsLegacy.metadata[m.CustomerKey]?.status,
                 };
             }
         }
@@ -318,6 +334,29 @@ class Automation extends MetadataType {
             throw new Error(JSON.stringify(results));
         }
     }
+    /**
+     * helper for {@link Automation.postRetrieveTasks} and {@link Automation.execute}
+     *
+     * @param {TYPE.AutomationItem} metadata a single automation
+     * @returns {boolean} true if the automation schedule is valid
+     */
+    static #isValidSchedule(metadata) {
+        if (metadata.type === 'scheduled' && metadata.schedule?.startDate) {
+            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`
+                );
+            }
+            return true;
+        } else {
+            return false;
+        }
+    }
     /**
      * manages post retrieve steps
      *
@@ -332,34 +371,24 @@ class Automation extends MetadataType {
             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.`
-                    );
+                if (!this.#isValidSchedule(metadata)) {
                     return;
                 }
+                // type 'Running' is temporary status only, overwrite with Scheduled for storage.
+                if (metadata.type === 'scheduled' && metadata.status === 'Running') {
+                    metadata.status = 'Scheduled';
+                }
             } else if (metadata.type === 'triggered' && metadata.fileTrigger) {
                 // Starting Source == 'File Drop'
                 // Do nothing for now
             }
             if (metadata.steps) {
+                let i = 0;
+
                 for (const step of metadata.steps) {
-                    const stepNumber = step.stepNumber || step.step;
+                    i++;
+
+                    const stepNumber = step.stepNumber || step.step || i;
                     delete step.stepNumber;
                     delete step.step;
 
@@ -387,14 +416,22 @@ class Automation extends MetadataType {
                             activity.activityObjectId == null
                         ) {
                             Util.logger.debug(
-                                ` - skip parsing of activity due to missing activityObjectId: ${JSON.stringify(
-                                    activity
-                                )}`
+                                ` - skipping ${
+                                    metadata[this.definition.keyField]
+                                } activity ${stepNumber}.${
+                                    activity.displayOrder
+                                } 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}`
+                                ` - skipping ${
+                                    metadata[this.definition.keyField]
+                                } activity ${stepNumber}.${
+                                    activity.displayOrder
+                                } because the type ${
+                                    activity.r__type
+                                } is not set up as a dependency for ${this.definition.type}`
                             );
                         }
                         // / if managed by cache we can update references to support deployment
@@ -445,6 +482,197 @@ class Automation extends MetadataType {
             return null;
         }
     }
+    /**
+     * a function to start query execution via API
+     *
+     * @param {string[]} keyArr customerkey of the metadata
+     * @returns {Promise.<string[]>} Returns list of keys that were executed
+     */
+    static async execute(keyArr) {
+        const metadataMap = {};
+        for (const key of keyArr) {
+            if (Util.OPTIONS.schedule) {
+                // schedule
+                const results = await this.retrieve(undefined, undefined, undefined, key);
+                if (Object.keys(results.metadata).length) {
+                    for (const resultKey of Object.keys(results.metadata)) {
+                        if (this.#isValidSchedule(results.metadata[resultKey])) {
+                            metadataMap[resultKey] = results.metadata[resultKey];
+                        } else {
+                            Util.logger.error(
+                                ` - skipping ${this.definition.type} ${results.metadata[resultKey].name}: no valid schedule settings found.`
+                            );
+                        }
+                    }
+                }
+            } else {
+                // runOnce
+                const objectId = await this.#getObjectIdForSingleRetrieve(key);
+                metadataMap[key] = {};
+                metadataMap[key][this.definition.idField] = objectId;
+                metadataMap[key][this.definition.keyField] = key;
+            }
+        }
+        if (!Object.keys(metadataMap).length) {
+            Util.logger.error(`No ${this.definition.type} to execute`);
+            return false;
+        }
+        Util.logger.info(
+            `Starting automations ${
+                Util.OPTIONS.schedule
+                    ? 'according to schedule'
+                    : 'to run once (use --schedule or --execute=schedule to schedule instead)'
+            }: ${Object.keys(metadataMap).length}`
+        );
+        const promiseResults = [];
+        for (const key of Object.keys(metadataMap)) {
+            if (Util.OPTIONS.schedule && metadataMap[key].status === 'Scheduled') {
+                // schedule
+                Util.logger.info(
+                    ` - skipping ${this.definition.type} ${metadataMap[key].name}: already scheduled.`
+                );
+            } else {
+                // schedule + runOnce
+                promiseResults.push(this.#executeItem(metadataMap, key));
+            }
+        }
+        const results = await Promise.all(promiseResults);
+        const executedKeyArr = results
+            .filter(Boolean)
+            .filter((r) => r.response.OverallStatus === 'OK')
+            .map((r) => r.key);
+        Util.logger.info(`Executed ${executedKeyArr.length} of ${keyArr.length} items`);
+        return executedKeyArr;
+    }
+    /**
+     * helper for {@link Automation.execute}
+     *
+     * @param {TYPE.AutomationMap} metadataMap map of metadata
+     * @param {string} key key of the metadata
+     * @returns {Promise.<{key:string, response:object}>} metadata key and API response
+     */
+    static async #executeItem(metadataMap, key) {
+        if (Util.OPTIONS.schedule) {
+            this.#preDeploySchedule(metadataMap[key]);
+            metadataMap[key].status = 'Scheduled';
+            return this.#scheduleAutomation(metadataMap, metadataMap, key);
+        } else {
+            return this.#runOnce(metadataMap[key]);
+        }
+    }
+
+    /**
+     * helper for {@link Automation.execute}
+     *
+     * @param {TYPE.AutomationItem} metadataEntry metadata object
+     * @returns {Promise.<{key:string, response:object}>} metadata key and API response
+     */
+    static async #runOnce(metadataEntry) {
+        return super.executeSOAP(metadataEntry);
+    }
+
+    /**
+     *  Standardizes a check for multiple messages but adds query specific filters to error texts
+     *
+     * @param {object} ex response payload from REST API
+     * @returns {string[] | void} formatted Error Message
+     */
+    static getErrorsREST(ex) {
+        const errors = super.getErrorsREST(ex);
+        if (errors?.length > 0) {
+            return errors.map((msg) =>
+                msg
+                    .split('403 Forbidden')
+                    .join('403 Forbidden: Please check if the automation is currently running.')
+            );
+        }
+        return errors;
+    }
+
+    /**
+     * a function to start query execution via API
+     *
+     * @param {string[]} keyArr customerkey of the metadata
+     * @returns {Promise.<string[]>} Returns list of keys that were paused
+     */
+    static async pause(keyArr) {
+        const metadataMap = {};
+        for (const key of keyArr) {
+            if (key) {
+                const results = await this.retrieve(undefined, undefined, undefined, key);
+                if (Object.keys(results.metadata).length) {
+                    for (const key of Object.keys(results.metadata)) {
+                        if (this.#isValidSchedule(results.metadata[key])) {
+                            metadataMap[key] = results.metadata[key];
+                        } else {
+                            Util.logger.error(
+                                ` - skipping ${this.definition.type} ${results.metadata[key].name}: no valid schedule settings found.`
+                            );
+                        }
+                    }
+                }
+            }
+        }
+
+        Util.logger.info(`Pausing automations: ${Object.keys(metadataMap).length}`);
+        const promiseResults = [];
+        for (const key of Object.keys(metadataMap)) {
+            if (metadataMap[key].status === 'Scheduled') {
+                promiseResults.push(this.#pauseItem(metadataMap[key]));
+            } else if (metadataMap[key].status === 'PausedSchedule') {
+                Util.logger.info(
+                    ` - skipping ${this.definition.type} ${metadataMap[key].name}: already paused.`
+                );
+            } else {
+                Util.logger.error(
+                    ` - skipping ${this.definition.type} ${
+                        metadataMap[key].name
+                    }: currently ${metadataMap[
+                        key
+                    ].status.toLowerCase()}. Please try again in a few minutes.`
+                );
+            }
+        }
+        const pausedKeyArr = (await Promise.all(promiseResults))
+            .filter(Boolean)
+            .filter((r) => r.response.OverallStatus === 'OK')
+            .map((r) => r.key);
+
+        Util.logger.info(`Paused ${pausedKeyArr.length} of ${keyArr.length} items`);
+        return pausedKeyArr;
+    }
+
+    /**
+     * helper for {@link Automation.pause}
+     *
+     * @param {TYPE.AutomationItem} metadata automation metadata
+     * @returns {Promise.<{key:string, response:object}>} metadata key and API response
+     */
+    static async #pauseItem(metadata) {
+        const schedule = {};
+        try {
+            const response = await this.client.soap.schedule(
+                'Automation',
+                schedule,
+                {
+                    Interaction: {
+                        ObjectID: metadata[this.definition.idField],
+                    },
+                },
+                'pause',
+                {}
+            );
+            Util.logger.info(
+                ` - paused ${this.definition.type}: ${metadata[this.definition.keyField]} / ${
+                    metadata[this.definition.nameField]
+                }`
+            );
+            return { key: metadata[this.definition.keyField], response };
+        } catch (ex) {
+            this._handleSOAPErrors(ex, 'pausing', metadata, false);
+            return null;
+        }
+    }
 
     /**
      * Deploys automation - the saved file is the original one due to large differences required for deployment
@@ -452,11 +680,10 @@ class Automation extends MetadataType {
      * @param {TYPE.AutomationMap} metadata metadata mapped by their keyField
      * @param {string} targetBU name/shorthand of target businessUnit for mapping
      * @param {string} retrieveDir directory where metadata after deploy should be saved
-     * @param {boolean} [isRefresh] optional flag - so far not used by automation
      * @returns {Promise.<TYPE.AutomationMap>} Promise
      */
-    static async deploy(metadata, targetBU, retrieveDir, isRefresh) {
-        const upsertResults = await this.upsert(metadata, targetBU, isRefresh);
+    static async deploy(metadata, targetBU, retrieveDir) {
+        const upsertResults = await this.upsert(metadata, targetBU);
         const savedMetadata = await this.saveResults(upsertResults, retrieveDir, null);
         if (
             this.properties.metaDataTypes.documentOnRetrieve.includes(this.definition.type) &&
@@ -488,11 +715,47 @@ class Automation extends MetadataType {
      * @returns {Promise} Promise
      */
     static update(metadata, metadataBefore) {
-        metadata.id = metadataBefore.id;
+        if (metadataBefore.status === 'Running') {
+            Util.logger.error(
+                ` ☇ error updating ${this.definition.type} ${
+                    metadata[this.definition.keyField] || metadata[this.definition.nameField]
+                } / ${
+                    metadata[this.definition.nameField]
+                }: You cannot update an automation that's currently running. Please wait a bit and retry.`
+            );
+            return null;
+        }
         const uri = '/automation/v1/automations/' + metadata.id;
         return super.updateREST(metadata, uri);
     }
 
+    /**
+     * helper for {@link Automation.preDeployTasks} and {@link Automation.execute}
+     *
+     * @param {TYPE.AutomationItem} metadata metadata mapped by their keyField
+     */
+    static #preDeploySchedule(metadata) {
+        delete metadata.schedule.rangeTypeId;
+        delete metadata.schedule.pattern;
+        delete metadata.schedule.scheduledTime;
+        delete metadata.schedule.scheduledStatus;
+        if (this.definition.timeZoneMapping[metadata.schedule.timezoneName]) {
+            metadata.schedule.timezoneId =
+                this.definition.timeZoneMapping[metadata.schedule.timezoneName];
+        } else {
+            Util.logger.error(
+                `Could not find timezone ${metadata.schedule.timezoneName} in definition.timeZoneMapping`
+            );
+        }
+
+        // the upsert API needs this to be named scheduleTypeId; the retrieve API returns it as typeId
+        metadata.schedule.scheduleTypeId = metadata.schedule.typeId;
+        delete metadata.schedule.typeId;
+
+        // prep startSource
+        metadata.startSource = { schedule: metadata.schedule, typeId: 1 };
+    }
+
     /**
      * Gets executed before deploying metadata
      *
@@ -516,25 +779,12 @@ class Automation extends MetadataType {
             if (metadata.type === 'scheduled' && metadata?.schedule?.startDate) {
                 // Starting Source == 'Schedule'
 
-                delete metadata.schedule.rangeTypeId;
-                delete metadata.schedule.pattern;
-                delete metadata.schedule.scheduledTime;
-                delete metadata.schedule.scheduledStatus;
-                if (this.definition.timeZoneMapping[metadata.schedule.timezoneName]) {
-                    metadata.schedule.timezoneId =
-                        this.definition.timeZoneMapping[metadata.schedule.timezoneName];
-                } else {
-                    Util.logger.error(
-                        `Could not find timezone ${metadata.schedule.timezoneName} in definition.timeZoneMapping`
-                    );
-                }
-                delete metadata.schedule.timezoneName;
-                // the upsert API needs this to be named scheduleTypeId; the retrieve API returns it as typeId
-                metadata.schedule.scheduleTypeId = metadata.schedule.typeId;
-                delete metadata.schedule.typeId;
+                this.#preDeploySchedule(metadata);
+                // * run _buildSchedule here but only to check if things look ok - do not use the returned schedule object for deploy
+                this._buildSchedule(metadata.schedule);
 
-                // prep startSource
-                metadata.startSource = { schedule: metadata.schedule, typeId: 1 };
+                delete metadata.schedule.timezoneName;
+                delete metadata.startSource.schedule.timezoneName;
             } else if (metadata.type === 'triggered' && metadata.fileTrigger) {
                 // Starting Source == 'File Drop'
 
@@ -632,6 +882,16 @@ class Automation extends MetadataType {
         }
         return deployable;
     }
+    /**
+     * helper for {@link MetadataType.updateREST} and {@link MetadataType.updateSOAP} that removes old files after the key was changed
+     *
+     * @private
+     * @param {TYPE.MetadataTypeItem} metadataEntry a single metadata Entry
+     * @returns {void}
+     */
+    static async _postChangeKeyTasks(metadataEntry) {
+        super._postChangeKeyTasks(metadataEntry, true);
+    }
 
     /**
      * Gets executed after deployment of metadata type
@@ -642,21 +902,53 @@ class Automation extends MetadataType {
      */
     static async postDeployTasks(metadataMap, originalMetadataMap) {
         for (const key in metadataMap) {
+            const item = metadataMap[key];
+
+            const oldKey = Util.changedKeysMap?.[this.definition.type]?.[key] || key;
+            delete Util.changedKeysMap?.[this.definition.type]?.[key];
+
+            if (!item.type) {
+                // create response does not return the type attribute
+
+                const scheduleHelper = item.schedule || item.startSource.schedule;
+
+                // el.type
+                item.type = scheduleHelper
+                    ? 'scheduled'
+                    : item.fileTrigger
+                    ? 'triggered'
+                    : undefined;
+
+                // el.schedule.timezoneName
+                if (item.type === 'scheduled') {
+                    // not existing for triggered automations
+                    scheduleHelper.timezoneName ||= Util.inverseGet(
+                        this.definition.timeZoneMapping,
+                        scheduleHelper.timezoneId
+                    );
+                }
+
+                // el.status
+                item.status ||= Util.inverseGet(this.definition.statusMapping, item.statusId);
+            }
             // need to put schedule on here if status is scheduled
-            await Automation.#scheduleAutomation(metadataMap, originalMetadataMap, key);
+            await Automation.#scheduleAutomation(metadataMap, originalMetadataMap, key, oldKey);
 
             // 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) {
+            if (item.steps) {
+                for (const step of item.steps) {
                     step.name = step.annotation;
                     delete step.annotation;
                 }
             }
         }
+        if (Util.OPTIONS.execute || Util.OPTIONS.schedule) {
+            Util.logger.info(`Executing: ${this.definition.type}`);
+            await this.execute(Object.keys(metadataMap));
+        }
     }
     /**
      * helper for {@link Automation.postDeployTasks}
@@ -706,22 +998,26 @@ class Automation extends MetadataType {
     }
 
     /**
-     * helper for {@link postDeployTasks}
+     * helper for {@link Automation.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
+     * @param {string} [oldKey] old customer key before fixKey / changeKeyValue / changeKeyField
+     * @returns {Promise.<{key:string, response:object}>} metadata key and API response
      */
-    static async #scheduleAutomation(metadataMap, originalMetadataMap, key) {
-        if (originalMetadataMap[key]?.type === 'scheduled') {
+    static async #scheduleAutomation(metadataMap, originalMetadataMap, key, oldKey) {
+        let response = null;
+        oldKey ||= key;
+        if (originalMetadataMap[oldKey]?.type === 'scheduled') {
             // Starting Source == 'Schedule': Try starting the automation
-            if (originalMetadataMap[key].status === 'Scheduled') {
+            if (originalMetadataMap[oldKey].status === 'Scheduled') {
                 let schedule = null;
                 try {
-                    schedule = this._buildSchedule(originalMetadataMap[key].schedule);
+                    schedule = this._buildSchedule(originalMetadataMap[oldKey].schedule);
                 } catch (ex) {
                     Util.logger.error(
-                        `- Could not create schedule for automation '${originalMetadataMap[key].name}' to start it: ${ex.message}`
+                        `- Could not create schedule for automation '${originalMetadataMap[oldKey].name}' to start it: ${ex.message}`
                     );
                 }
                 if (schedule !== null) {
@@ -734,12 +1030,12 @@ class Automation extends MetadataType {
                         const schedule_timezoneString = schedule._timezoneString;
                         delete schedule._timezoneString;
                         // start the automation
-                        await this.client.soap.schedule(
+                        response = await this.client.soap.schedule(
                             'Automation',
                             schedule,
                             {
                                 Interaction: {
-                                    ObjectID: metadataMap[key].id,
+                                    ObjectID: metadataMap[key][this.definition.idField],
                                 },
                             },
                             'start',
@@ -753,21 +1049,22 @@ class Automation extends MetadataType {
                                   (schedule_interval > 1 ? 's' : ''));
                         Util.logger.warn(
                             ` - scheduled automation '${
-                                originalMetadataMap[key].name
+                                originalMetadataMap[oldKey].name
                             }' deployed as Active: runs every ${intervalString} starting ${
                                 schedule_StartDateTime.split('T').join(' ').split('.')[0]
                             } ${schedule_timezoneString}`
                         );
-                    } catch (ex) {
+                    } catch {
+                        // API does not return anything usefull here. We have to know the rules instead
                         Util.logger.error(
-                            `- Could not start scheduled automation '${originalMetadataMap[key].name}': ${ex.message}`
+                            ` ☇ error starting scheduled ${this.definition.type}${key}: Please check schedule settings`
                         );
                     }
                 }
             } else {
                 Util.logger.info(
                     Util.getGrayMsg(
-                        ` - scheduled automation '${originalMetadataMap[key].name}' deployed as Paused`
+                        ` - scheduled automation '${originalMetadataMap[oldKey].name}' deployed as Paused`
                     )
                 );
             }
@@ -781,6 +1078,7 @@ class Automation extends MetadataType {
             metadataMap[key].schedule.typeId = metadataMap[key].schedule.scheduleTypeId;
             delete metadataMap[key].schedule.scheduleTypeId;
         }
+        return { key, response };
     }
 
     /**
@@ -867,6 +1165,9 @@ class Automation extends MetadataType {
             const a = obj.split('=');
             recurHelper[a[0]] = a[1];
         }
+        if (recurHelper.INTERVAL) {
+            recurHelper.INTERVAL = Number.parseInt(recurHelper.INTERVAL);
+        }
         // the ical schedule is all in caps but soap objects require Title Case.
         const keyStem = recurHelper.FREQ.charAt(0) + recurHelper.FREQ.slice(1, -2).toLowerCase();
 
@@ -895,13 +1196,18 @@ class Automation extends MetadataType {
                 'Scheduling automatically not supported for Weekly, Monthly and Yearly, please configure manually.'
             );
         }
+        if (recurHelper.FREQ === 'MINUTELY' && recurHelper.INTERVAL && recurHelper.INTERVAL < 5) {
+            throw new Error(
+                'The smallest interval you can configure is 5 minutes. Please adjust your schedule.'
+            );
+        }
 
         if (this.definition.timeZoneMapping[scheduleObject.timezoneName]) {
             scheduleObject.timezoneId =
                 this.definition.timeZoneMapping[scheduleObject.timezoneName];
         } else {
-            Util.logger.error(
-                `- Could not find timezone ${scheduleObject.timezoneName} in definition.timeZoneMapping`
+            throw new Error(
+                `Could not find timezone ${scheduleObject.timezoneName} in definition.timeZoneMapping`
             );
         }
         schedule.TimeZone.ID = scheduleObject.timezoneId;
@@ -995,8 +1301,8 @@ class Automation extends MetadataType {
         // create new Date object reflecting SFMC's servertime
         const dateServer = new Date(utc + 3600000 * offsetServer);
 
-        // return time as a string without trailing "Z"
-        return dateServer.toISOString().slice(0, -1);
+        // return time as a string without trailing "Z" and without miliseconds (separated by .)
+        return dateServer.toISOString().slice(0, -1).split('.')[0];
     }
     /**
      * Experimental: Only working for DataExtensions:
@@ -1023,7 +1329,7 @@ class Automation extends MetadataType {
         const automationType = { scheduled: 'Schedule', triggered: 'File Drop' };
         output += `**Started by:** ${automationType[json.type] || 'Not defined'}\n\n`;
         output += `**Status:** ${json.status}\n\n`;
-        if (json.type === 'scheduled') {
+        if (json.type === 'scheduled' || json.schedule) {
             const tz =
                 this.definition.timeZoneDifference[
                     this.definition.timeZoneMapping[json?.schedule?.timezoneName]
@@ -1033,7 +1339,7 @@ class Automation extends MetadataType {
                 output += `**Schedule:**\n\n`;
                 output += `* Start: ${json.schedule.startDate.split('T').join(' ')} ${tz}\n`;
                 output += `* End: ${json.schedule.endDate.split('T').join(' ')} ${tz}\n`;
-                output += `* Timezone:  ${json.schedule.timezoneName}\n`;
+                output += `* Timezone: ${json.schedule.timezoneName}\n`;
 
                 const ical = {};
                 for (const item of json.schedule.icalRecur.split(';')) {
@@ -1042,9 +1348,20 @@ class Automation extends MetadataType {
                 }
                 const frequency = ical.FREQ.slice(0, -2).toLowerCase();
 
-                output += `* Recurrance: every ${ical.INTERVAL > 1 ? ical.INTERVAL : ''} ${
-                    frequency === 'dai' ? 'day' : frequency
-                }${ical.INTERVAL > 1 ? 's' : ''} ${ical.COUNT ? `for ${ical.COUNT} times` : ''}\n`;
+                output += `* Recurrance: `;
+                output +=
+                    ical.COUNT == 1
+                        ? 'run only once'
+                        : `every${ical.INTERVAL > 1 ? ' ' + ical.INTERVAL : ''} ${
+                              frequency === 'dai' ? 'day' : frequency
+                          }${ical.INTERVAL > 1 ? 's' : ''}${
+                              ical.COUNT
+                                  ? ` for ${ical.COUNT} times`
+                                  : ical.UNTIL
+                                  ? ' until end date'
+                                  : ''
+                          }`;
+                output += '\n';
             } else if (json.schedule) {
                 output += `**Schedule:** Not defined\n`;
             }
@@ -1224,7 +1541,7 @@ class Automation extends MetadataType {
      * @param {string} key customer key
      * @returns {Promise.<string>} objectId or enpty string
      */
-    static async _getObjectIdForSingleRetrieve(key) {
+    static async #getObjectIdForSingleRetrieve(key) {
         const response = await this.client.soap.retrieve('Program', ['ObjectID'], {
             filter: {
                 leftOperand: 'CustomerKey',
@@ -1243,7 +1560,7 @@ class Automation extends MetadataType {
      */
     static async deleteByKey(customerKey) {
         // the delete endpoint returns a general exception if the automation does not exist; handle it gracefully instead by adding a retrieve first
-        const objectId = customerKey ? await this._getObjectIdForSingleRetrieve(customerKey) : null;
+        const objectId = customerKey ? await this.#getObjectIdForSingleRetrieve(customerKey) : null;
         if (!objectId) {
             Util.logger.error(` - automation not found`);
             return false;