mcdev 7.10.0 → 7.10.1

package/lib/metadataTypes/Automation.js

@@ -146,12 +146,11 @@ class Automation extends MetadataType {
      * helper for {@link Automation.retrieve} to get Automation Notifications
      *
      * @param {MetadataTypeMap} metadataMap keyField => metadata map
+     * @param {boolean} [skipNotification] skip notification retrieval
      * @returns {Promise.<object>} Promise of automation legacy api response
      */
-    static async #getAutomationLegacyREST(metadataMap) {
-        Util.logger.info(
-            Util.getGrayMsg(` Retrieving Automation Notification & wait information...`)
-        );
+    static async #getAutomationLegacyREST(metadataMap, skipNotification = false) {
+        Util.logger.info(Util.getGrayMsg(` Retrieving additional automation details...`));
 
         // get list of keys that we retrieved so far
         const foundKeys = Object.keys(metadataMap);
@@ -172,27 +171,9 @@ class Automation extends MetadataType {
                 id: automationLegacyMapObj.metadata[key].id,
                 key,
             }));
-        // wait
-        const waitLegacyMap = Object.keys(automationLegacyMapObj.metadata)
+        // created / modified / paused / wait activities
+        const extendedDetailsLegacyMap = Object.keys(automationLegacyMapObj.metadata)
             .filter((key) => foundKeys.includes(key))
-            .filter((key) => {
-                const steps = automationLegacyMapObj.metadata[key].processes;
-                // wait activities
-                if (!Array.isArray(steps)) {
-                    return false;
-                }
-                for (const step of steps) {
-                    if (!Array.isArray(step.workerCounts)) {
-                        continue;
-                    }
-                    for (const activity of step.workerCounts) {
-                        if (activity.objectTypeId === 467) {
-                            return true;
-                        }
-                    }
-                }
-                return false;
-            })
             .map((key) => ({
                 id: automationLegacyMapObj.metadata[key].id,
                 key,
@@ -202,31 +183,61 @@ class Automation extends MetadataType {
 
         // get wait activities for automations using it
         await Promise.all(
-            waitLegacyMap.map((automationLegacy) =>
+            extendedDetailsLegacyMap.map((automationLegacy) =>
                 // notifications
                 rateLimit(async () => {
                     // this is a file so extended is at another endpoint
                     try {
-                        const waitResult = await this.client.rest.get(
+                        /** @type {AutomationItem} */
+                        const item = metadataMap[automationLegacy.key];
+                        item.legacyId = automationLegacy.id;
+
+                        const extended = await this.client.rest.get(
                             `/legacy/v1/beta/bulk/automations/automation/definition/` +
                                 automationLegacy.id
                         );
-                        if (Array.isArray(waitResult?.processes)) {
-                            const steps = waitResult.processes;
-                            // wait activities
-                            for (const step of steps) {
+                        // set those for {@link schedule}
+                        item.type ||= extended.automationType;
+                        item.status ||= extended.status;
+
+                        // created
+                        item.createdName = extended.createdBy?.name;
+                        item.createdDate = extended.createdDate;
+
+                        // last modified
+                        item.modifiedName = extended.lastSavedBy?.name;
+                        item.modifiedDate = extended.lastSaveDate;
+
+                        // last paused
+                        item.pausedName = extended.lastPausedBy?.name;
+                        item.pausedDate = extended.lastPausedDate;
+
+                        // schedule id for activating the schedule
+                        if (extended?.scheduleObject?.id && item.schedule) {
+                            // save schedule id in cached metadata for retrieval during scheduling
+                            item.schedule.id = extended.scheduleObject.id;
+                        }
+
+                        // add timezone to wait activities
+                        if (Array.isArray(extended?.processes)) {
+                            for (const step of extended.processes) {
+                                // steps
+                                if (!Array.isArray(step?.workers)) {
+                                    continue;
+                                }
                                 for (const activity of step.workers) {
+                                    // activties
                                     if (
                                         activity.objectTypeId === 467 &&
                                         activity.serializedObject
                                     ) {
+                                        // wait activities
                                         const waitObj = JSON.parse(activity.serializedObject);
                                         if (waitObj.timeZone) {
                                             // add timezone to the wait activity
-                                            metadataMap[automationLegacy.key].steps[
-                                                step.sequence
-                                            ].activities[activity.sequence].timeZone =
-                                                waitObj.timeZone;
+                                            item.steps[step.sequence].activities[
+                                                activity.sequence
+                                            ].timeZone = waitObj.timeZone;
                                         }
                                         // * wait activities are not supported in the new API
                                     }
@@ -235,13 +246,16 @@ class Automation extends MetadataType {
                         }
                     } catch (ex) {
                         Util.logger.debug(
-                            ` ☇ issue retrieving wait details for automation ${automationLegacy.key}: ${ex.message} ${ex.code}`
+                            ` ☇ issue retrieving extended details for automation ${automationLegacy.key}: ${ex.message} ${ex.code}`
                         );
                     }
                 })
             )
         );
 
+        if (skipNotification) {
+            return;
+        }
         // get notifications for each automation
         let found = 0;
         let skipped = 0;
@@ -644,220 +658,179 @@ class Automation extends MetadataType {
             return null;
         }
     }
-
     /**
-     * a function to start query execution via API
+     * a function to active the schedule of an automation
      *
      * @param {string[]} keyArr customerkey of the metadata
      * @returns {Promise.<string[]>} Returns list of keys that were executed
      */
-    static async execute(keyArr) {
-        /** @type {AutomationMap} */
+    static async schedule(keyArr) {
+        return this.#schedulePause('schedule', keyArr);
+    }
+    /**
+     * a function to pause the schedule of an automation
+     *
+     * @param {string[]} keyArr customerkey of the metadata
+     * @returns {Promise.<string[]>} Returns list of keys that were executed
+     */
+    static async pause(keyArr) {
+        return this.#schedulePause('pause', keyArr);
+    }
+    /**
+     * a function to active the schedule of an automation
+     *
+     * @param {'schedule'|'pause'} mode what to do
+     * @param {string[]} keyArr customerkey of the metadata
+     * @returns {Promise.<string[]>} Returns list of keys that were executed
+     */
+    static async #schedulePause(mode, 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);
-                /** @type {AutomationItem} */
-                metadataMap[key] = { key, id: objectId };
+            metadataMap[key] = { key, schedule: {} };
+        }
+        await this.#getAutomationLegacyREST(metadataMap, true);
+        for (const key of keyArr) {
+            const item = metadataMap[key];
+            if (!item.type) {
+                Util.logger.error(
+                    ` ☇ skipping ${Util.getTypeKeyName(this.definition, item)}: automation not found.`
+                );
+                delete metadataMap[key];
+            } else if (item.type !== 'scheduled') {
+                Util.logger.error(
+                    ` ☇ skipping ${Util.getTypeKeyName(this.definition, item)}: cannot ${mode} an automation of type '${item.type}'.`
+                );
+                delete metadataMap[key];
             }
         }
         if (!Object.keys(metadataMap).length) {
-            Util.logger.error(`No ${this.definition.type} to execute`);
-            return;
+            Util.logger.error(`No ${this.definition.type} to ` + mode);
+            return [];
         }
-        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}`
-        );
+        Util.logger.info(`${mode === 'schedule' ? 'Activating' : 'Pausing'} automations`);
         const promiseResults = [];
         for (const key of Object.keys(metadataMap)) {
-            if (Util.OPTIONS.schedule && metadataMap[key].status === 'Scheduled') {
+            /** @type {AutomationItem} */
+            const item = metadataMap[key];
+            if (item.status === (mode === 'schedule' ? 'Scheduled' : 'PausedSchedule')) {
                 // schedule
                 Util.logger.info(
-                    ` - skipping ${this.definition.type} ${metadataMap[key].name}: already scheduled.`
+                    ` ☇ skipping ${Util.getTypeKeyName(this.definition, item)}: already ${mode === 'schedule' ? 'activated' : 'paused'}.`
                 );
             } else {
-                // schedule + runOnce
-                promiseResults.push(this.#executeItem(metadataMap, key));
+                // schedule
+                promiseResults.push(
+                    this.#schedulePauseItem(mode, key, item.legacyId, item.schedule.id)
+                );
             }
         }
         const results = await Promise.all(promiseResults);
-        const executedKeyArr = results
+        const updatedKeyArr = results
             .filter(Boolean)
-            .filter((r) => r.response.OverallStatus === 'OK')
+            .filter((r) => r.response.id)
             .map((r) => r.key);
-        Util.logger.info(`Executed ${executedKeyArr.length} of ${keyArr.length} items`);
-        return executedKeyArr;
-    }
+        Util.logger.info(
+            `${mode === 'schedule' ? 'Activated' : 'Paused'} ${updatedKeyArr.length} of ${keyArr.length} items`
+        );
 
-    /**
-     * helper for {@link Automation.execute}
-     *
-     * @param {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]);
-        }
+        return updatedKeyArr;
     }
 
     /**
-     * helper for {@link Automation.execute}
+     * helper for {@link Automation.schedule}
      *
-     * @param {AutomationItem} metadataEntry metadata object
+     * @param {'schedule'|'pause'} mode what to do
+     * @param {string} key automation key
+     * @param {string} automationLegacyId automation id
+     * @param {string} [scheduleLegacyId] schedule id
      * @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[]} 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.')
+    static async #schedulePauseItem(mode, key, automationLegacyId, scheduleLegacyId) {
+        if (!scheduleLegacyId) {
+            const extended = await this.client.rest.get(
+                `/legacy/v1/beta/bulk/automations/automation/definition/` + automationLegacyId
+            );
+            if (extended.scheduleObject?.id) {
+                scheduleLegacyId = extended.scheduleObject.id;
+            } else {
+                Util.logger.error(
+                    ` ☇ skipping ${this.definition.type} ${key}: no valid schedule settings found.`
+                );
+                return null;
+            }
+        }
+        const response = await this.client.rest.post(
+            '/legacy/v1/beta/bulk/automations/automation/definition/?action=' +
+                (mode === 'schedule' ? 'schedule' : 'pauseSchedule'),
+            {
+                id: automationLegacyId,
+                scheduleObject: {
+                    id: scheduleLegacyId,
+                },
+            }
+        );
+        if (response?.id === automationLegacyId) {
+            const item = {};
+            item[this.definition.keyField] = key;
+            Util.logger.info(
+                ` - ${mode === 'schedule' ? '✅ activated' : '🛑 paused'} scheduled ${Util.getTypeKeyName(this.definition, item)}`
             );
         }
-        return errors;
-    }
 
+        return { key, response };
+    }
     /**
      * 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
+     * @returns {Promise.<string[]>} Returns list of keys that were executed
      */
-    static async pause(keyArr) {
+    static async execute(keyArr) {
+        /** @type {AutomationMap} */
         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.`
-                            );
-                        }
-                    }
-                }
-            }
+            // runOnce
+            const objectId = await this.#getObjectIdForSingleRetrieve(key);
+            /** @type {AutomationItem} */
+            metadataMap[key] = { key, id: objectId };
         }
-
-        Util.logger.info(`Pausing automations: ${Object.keys(metadataMap).length}`);
+        if (!Object.keys(metadataMap).length) {
+            Util.logger.error(`No ${this.definition.type} to execute`);
+            return;
+        }
+        Util.logger.info(
+            `Starting automations 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 (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.`
-                );
-            }
+            // schedule + runOnce
+            promiseResults.push(super.executeSOAP(metadataMap[key]));
         }
-        const pausedKeyArr = (await Promise.all(promiseResults))
+        const results = await Promise.all(promiseResults);
+        const executedKeyArr = results
             .filter(Boolean)
             .filter((r) => r.response.OverallStatus === 'OK')
             .map((r) => r.key);
-
-        Util.logger.info(`Paused ${pausedKeyArr.length} of ${keyArr.length} items`);
-        return pausedKeyArr;
+        Util.logger.info(`Executed ${executedKeyArr.length} of ${keyArr.length} items`);
+        return executedKeyArr;
     }
 
     /**
-     * helper for {@link Automation.pause}
+     *  Standardizes a check for multiple messages but adds query specific filters to error texts
      *
-     * @param {AutomationItem} metadata automation metadata
-     * @returns {Promise.<{key:string, response:object}>} metadata key and API response
+     * @param {object} ex response payload from REST API
+     * @returns {string[]} formatted Error Message
      */
-    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]
-                }`
+    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 { 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
-     *
-     * @param {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
-     * @returns {Promise.<AutomationMap>} Promise
-     */
-    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) &&
-            !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;
+        return errors;
     }
 
     /**
@@ -965,7 +938,7 @@ class Automation extends MetadataType {
 
                 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);
+                this._checkSchedule(metadata.schedule);
 
                 delete metadata.schedule.timezoneName;
                 delete metadata.startSource.schedule.timezoneName;
@@ -1144,10 +1117,9 @@ class Automation extends MetadataType {
      * Gets executed after deployment of metadata type
      *
      * @param {AutomationMap} metadataMap metadata mapped by their keyField
-     * @param {AutomationMap} originalMetadataMap metadata to be updated (contains additioanl fields)
      * @returns {Promise.<void>} -
      */
-    static async postDeployTasks(metadataMap, originalMetadataMap) {
+    static async postDeployTasks(metadataMap) {
         for (const key in metadataMap) {
             const item = metadataMap[key];
 
@@ -1156,8 +1128,12 @@ class Automation extends MetadataType {
 
             if (!item.type) {
                 // create response does not return the type attribute
-
-                const scheduleHelper = item.schedule || item.startSource.schedule;
+                if (item.startSource?.schedule) {
+                    // rewrite upsert reponse into retrieve format
+                    item.schedule = item.startSource.schedule;
+                    delete item.startSource;
+                }
+                const scheduleHelper = item.schedule;
 
                 // el.type
                 item.type = scheduleHelper
@@ -1179,7 +1155,13 @@ class Automation extends MetadataType {
                 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, oldKey);
+            if (Util.OPTIONS.schedule) {
+                await Automation.#schedulePauseItem(
+                    'schedule',
+                    oldKey || key,
+                    metadataMap[key]?.legacyId
+                );
+            }
 
             // need to update notifications separately if there are any
             await Automation.#updateNotificationInfoREST(metadataMap, key);
@@ -1192,10 +1174,24 @@ class Automation extends MetadataType {
                 }
             }
         }
-        if (Util.OPTIONS.execute || Util.OPTIONS.schedule) {
+
+        if (Util.OPTIONS.execute) {
             Util.logger.info(`Executing: ${this.definition.type}`);
             await this.execute(Object.keys(metadataMap));
         }
+        Util.logger.debug(
+            `Caching all ${this.definition.type} post-deploy to ensure we have all fields`
+        );
+
+        // post-deploy re-retrieve
+        // dont use retrieveForCache here because that is simplified for automations
+        const typeCache = await this.retrieve();
+        // update values in upsertResults with retrieved values before saving to disk
+        for (const key of Object.keys(metadataMap)) {
+            if (typeCache.metadata[key]) {
+                metadataMap[key] = typeCache.metadata[key];
+            }
+        }
     }
 
     /**
@@ -1245,90 +1241,6 @@ class Automation extends MetadataType {
         }
     }
 
-    /**
-     * helper for {@link Automation.postDeployTasks}
-     *
-     * @param {AutomationMap} metadataMap metadata mapped by their keyField
-     * @param {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, oldKey) {
-        let response = null;
-        oldKey ||= key;
-        if (originalMetadataMap[oldKey]?.type === 'scheduled') {
-            // Starting Source == 'Schedule': Try starting the automation
-            if (originalMetadataMap[oldKey].status === 'Scheduled') {
-                let schedule = null;
-                try {
-                    schedule = this._buildSchedule(originalMetadataMap[oldKey].schedule);
-                } catch (ex) {
-                    Util.logger.error(
-                        `- Could not create schedule for automation '${originalMetadataMap[oldKey].name}' to start it: ${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
-                        response = await this.client.soap.schedule(
-                            'Automation',
-                            schedule,
-                            {
-                                Interaction: {
-                                    ObjectID: metadataMap[key][this.definition.idField],
-                                },
-                            },
-                            '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[oldKey].name
-                            }' deployed as Active: runs every ${intervalString} starting ${
-                                schedule_StartDateTime.split('T').join(' ').split('.')[0]
-                            } ${schedule_timezoneString}`
-                        );
-                    } catch {
-                        // API does not return anything usefull here. We have to know the rules instead
-                        Util.logger.error(
-                            ` ☇ error starting scheduled ${this.definition.type}${key}: Please check schedule settings`
-                        );
-                    }
-                }
-            } else {
-                Util.logger.info(
-                    Util.getGrayMsg(
-                        ` - scheduled automation '${originalMetadataMap[oldKey].name}' deployed as Paused`
-                    )
-                );
-            }
-        }
-        if (metadataMap[key].startSource) {
-            metadataMap[key].schedule = metadataMap[key].startSource.schedule;
-
-            delete metadataMap[key].startSource;
-        }
-        if (metadataMap[key].schedule?.scheduleTypeId) {
-            metadataMap[key].schedule.typeId = metadataMap[key].schedule.scheduleTypeId;
-            delete metadataMap[key].schedule.scheduleTypeId;
-        }
-        return { key, response };
-    }
-
     /**
      * generic script that retrieves the folder path from cache and updates the given metadata with it after retrieve
      *
@@ -1369,18 +1281,9 @@ class Automation extends MetadataType {
      * based on combination of ical string and start/end dates.
      *
      * @param {AutomationSchedule} scheduleObject child of automation metadata used for scheduling
-     * @returns {AutomationScheduleSoap} Schedulable object for soap API (currently not rest supported)
+     * @returns {void} throws and error in case of problems
      */
-    static _buildSchedule(scheduleObject) {
-        /**
-         * @type {AutomationScheduleSoap}
-         */
-        const schedule = {
-            Recurrence: {},
-            TimeZone: { ID: null, IDSpecified: true },
-            RecurrenceRangeType: null,
-            StartDateTime: null,
-        };
+    static _checkSchedule(scheduleObject) {
         // build recurrence
         const recurHelper = {};
         // ical values are split by ; then have key values split by =
@@ -1391,34 +1294,7 @@ class Automation extends MetadataType {
         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();
-
-        const patternType = recurHelper['BYMONTH']
-            ? 'ByMonth'
-            : recurHelper['BYWEEK']
-              ? 'ByWeek'
-              : recurHelper['BYDAY']
-                ? 'ByDay'
-                : 'Interval';
-        schedule.Recurrence[keyStem + 'lyRecurrencePatternType'] = patternType;
-        schedule.Recurrence['@_xsi:type'] = keyStem + 'lyRecurrence';
-        schedule.RecurrenceType = keyStem + 'ly';
-        if (keyStem === 'Dai') {
-            schedule.Recurrence['DayInterval'] = recurHelper.INTERVAL;
-        } else {
-            schedule.Recurrence[keyStem + 'Interval'] = recurHelper.INTERVAL;
-        }
-        schedule._interval = recurHelper.INTERVAL; // for CLI output only
 
-        if (!['Minute', 'Hour', 'Dai'].includes(keyStem)) {
-            // todo: add support for weekly
-            // todo: add support for monthly
-            // todo: add support for yearly
-            throw new Error(
-                '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.'
@@ -1433,79 +1309,6 @@ class Automation extends MetadataType {
                 `Could not find timezone ${scheduleObject.timezoneName} in definition.timeZoneMapping`
             );
         }
-        schedule.TimeZone.ID = scheduleObject.timezoneId;
-        schedule._timezoneString = this.definition.timeZoneDifference[scheduleObject.timezoneId];
-
-        // add tz to input date to ensure Date() creates a date object with the right tz
-        const inputStartDateString = scheduleObject.startDate + schedule._timezoneString;
-
-        /** @type {Date | string} */
-        let startDateTime;
-        if (new Date(inputStartDateString) > new Date()) {
-            // if start date is in future take this
-            startDateTime = scheduleObject.startDate;
-            schedule._StartDateTime = scheduleObject.startDate; // store copy for CLI output
-        } else {
-            // if start date is in past calculate new start date
-            const scheduledDate = new Date(inputStartDateString);
-            const futureDate = new Date();
-
-            switch (keyStem) {
-                case 'Dai': {
-                    // keep time from template and start today if possible
-                    if (scheduledDate.getHours() <= futureDate.getHours()) {
-                        // hour on template has already passed today, start tomorrow
-                        futureDate.setDate(futureDate.getDate() + 1);
-                    }
-                    futureDate.setHours(scheduledDate.getHours());
-                    futureDate.setMinutes(scheduledDate.getMinutes());
-
-                    break;
-                }
-                case 'Hour': {
-                    // keep minute and start next possible hour
-                    if (scheduledDate.getMinutes() <= futureDate.getMinutes()) {
-                        futureDate.setHours(futureDate.getHours() + 1);
-                    }
-                    futureDate.setMinutes(scheduledDate.getMinutes());
-
-                    break;
-                }
-                case 'Minute': {
-                    // schedule in next 15 minutes randomly to avoid that all automations run at exactly
-                    // earliest start 1 minute from now
-                    // the same time which would slow performance
-                    futureDate.setMinutes(
-                        futureDate.getMinutes() + 1 + Math.ceil(Math.random() * 15)
-                    );
-
-                    break;
-                }
-                // No default
-            }
-            // return time as Dateobject
-            startDateTime = futureDate;
-            const localTimezoneOffset = futureDate.getTimezoneOffset() / -60;
-            schedule._StartDateTime = this._calcTime(localTimezoneOffset, futureDate); // store copy for CLI output
-        }
-
-        // The Create/Update API expects dates to be in US-Central time
-        // The retrieve API returns the date in whatever timezone one chose, hence we need to convert this upon upsert
-        schedule.StartDateTime = this._calcTime(
-            this.properties.options.serverTimeOffset,
-            startDateTime,
-            schedule._timezoneString
-        );
-
-        if (recurHelper.UNTIL) {
-            schedule.RecurrenceRangeType = 'EndOn';
-            schedule.EndDateTime = scheduleObject.endDate;
-        } else {
-            schedule.RecurrenceRangeType = 'EndAfter';
-            schedule.Occurrences = recurHelper.COUNT;
-        }
-
-        return schedule;
     }
 
     /**
@@ -1799,7 +1602,7 @@ class Automation extends MetadataType {
         // the delete endpoint returns a general exception if the automation does not exist; handle it gracefully instead by adding a retrieve first
         const objectId = key ? await this.#getObjectIdForSingleRetrieve(key) : null;
         if (!objectId) {
-            Util.logger.error(` - automation ${key} not found`);
+            await this.deleteNotFound(key);
             return false;
         }
         return super.deleteByKeySOAP(key, 'CustomerKey');