mcdev 4.2.1 → 4.3.1

package/lib/metadataTypes/Query.js

@@ -5,6 +5,15 @@ const MetadataType = require('./MetadataType');
 const File = require('../util/file');
 const cache = require('../util/cache');
 const Mustache = require('mustache');
+/**
+ * ensure that Mustache does not escape any characters
+ *
+ * @param {string} text -
+ * @returns {string} text
+ */
+Mustache.escape = function (text) {
+    return text;
+};
 
 /**
  * Query MetadataType
@@ -18,11 +27,10 @@ class Query extends MetadataType {
      * @param {string} retrieveDir Directory where retrieved metadata directory will be saved
      * @param {void} [_] unused parameter
      * @param {void} [__] unused parameter
-     * @param {void} [___] unused parameter
      * @param {string} [key] customer key of single item to retrieve
      * @returns {Promise.<{metadata: TYPE.QueryMap, type: string}>} Promise of metadata
      */
-    static async retrieve(retrieveDir, _, __, ___, key) {
+    static async retrieve(retrieveDir, _, __, key) {
         await File.initPrettier('sql');
         const objectId = key ? await this._getObjectIdForSingleRetrieve(key) : null;
         return super.retrieveREST(
@@ -129,8 +137,9 @@ class Query extends MetadataType {
             'CustomerKey',
             'CustomerKey'
         );
-        metadata.categoryId = cache.searchForField('folder', metadata.r__folder_Path, 'Path', 'ID');
-        delete metadata.r__folder_Path;
+        // folder
+        super.setFolderId(metadata);
+
         metadata.targetUpdateTypeId =
             this.definition.targetUpdateTypeMapping[metadata.targetUpdateTypeName];
         return metadata;
@@ -156,7 +165,7 @@ class Query extends MetadataType {
             .join('}}}');
 
         // replace template variables with their values
-        return Mustache.render(code, templateVariables);
+        return Mustache.render(code, templateVariables, {}, ['{{{', '}}}']);
     }
     /**
      * helper for {@link MetadataType.buildDefinition}
@@ -327,7 +336,7 @@ class Query extends MetadataType {
      *  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
+     * @returns {string[] | void} formatted Error Message
      */
     static checkForErrors(ex) {
         const errors = super.checkForErrors(ex);

package/lib/metadataTypes/Role.js

@@ -16,13 +16,12 @@ class Role extends MetadataType {
      *
      * @param {string} retrieveDir Directory where retrieved metadata directory will be saved
      * @param {string[]} _ Returns specified fields even if their retrieve definition is not set to true
-     * @param {TYPE.BuObject} buObject properties for auth
      * @param {void} [___] unused parameter
      * @param {string} [key] customer key of single item to retrieve
      * @returns {Promise.<TYPE.MetadataTypeMapObj>} Metadata store object
      */
-    static async retrieve(retrieveDir, _, buObject, ___, key) {
-        if (retrieveDir && buObject.eid !== buObject.mid) {
+    static async retrieve(retrieveDir, _, ___, key) {
+        if (retrieveDir && this.buObject.eid !== this.buObject.mid) {
             // don't run for BUs other than Parent BU
             // this check does not work during caching
             Util.logger.info(' - Skipping Role retrieval on non-parent BU');
@@ -67,10 +66,11 @@ class Role extends MetadataType {
         if (retrieveDir) {
             const savedMetadata = await super.saveResults(parsed, retrieveDir, null);
             Util.logger.info(
-                `Downloaded: ${this.definition.type} (${Object.keys(savedMetadata).length})`
+                `Downloaded: ${this.definition.type} (${Object.keys(savedMetadata).length})` +
+                    Util.getKeysString(key)
             );
             if (this.properties.metaDataTypes.documentOnRetrieve.includes(this.definition.type)) {
-                await this.document(buObject, savedMetadata);
+                await this.document(savedMetadata);
             }
         }
         return { metadata: parsed, type: this.definition.type };
@@ -113,12 +113,11 @@ class Role extends MetadataType {
     /**
      * Creates markdown documentation of all roles
      *
-     * @param {TYPE.BuObject} buObject properties for auth
      * @param {TYPE.MetadataTypeMap} [metadata] role definitions
      * @returns {Promise.<void>} -
      */
-    static async document(buObject, metadata) {
-        if (buObject.eid !== buObject.mid) {
+    static async document(metadata) {
+        if (this.buObject.eid !== this.buObject.mid) {
             Util.logger.error(
                 `Roles can only be retrieved & documented for the ${Util.parentBuName}`
             );
@@ -129,7 +128,7 @@ class Role extends MetadataType {
                 metadata = this.readBUMetadataForType(
                     File.normalizePath([
                         this.properties.directories.retrieve,
-                        buObject.credential,
+                        this.buObject.credential,
                         Util.parentBuName,
                     ]),
                     true
@@ -159,7 +158,7 @@ class Role extends MetadataType {
             }
         }
         // Create output markdown
-        let output = `# Permission Overview - ${buObject.credential}\n\n`;
+        let output = `# Permission Overview - ${this.buObject.credential}\n\n`;
         output += `> **Legend**
 >
 > <hr>
@@ -211,7 +210,7 @@ class Role extends MetadataType {
             output += '\n';
         }
         try {
-            const filename = buObject.credential;
+            const filename = this.buObject.credential;
             // write to disk
             await File.writeToFile(directory, filename + '.roles', 'md', output);
             Util.logger.info(`Created ${File.normalizePath([directory, filename])}.roles.md`);

package/lib/metadataTypes/Script.js

@@ -4,7 +4,6 @@ const TYPE = require('../../types/mcdev.d');
 const MetadataType = require('./MetadataType');
 const Util = require('../util/util');
 const File = require('../util/file');
-const cache = require('../util/cache');
 
 /**
  * Script MetadataType
@@ -19,11 +18,10 @@ class Script extends MetadataType {
      * @param {string} retrieveDir Directory where retrieved metadata directory will be saved
      * @param {void} [_] unused parameter
      * @param {void} [__] unused parameter
-     * @param {void} [___] unused parameter
      * @param {string} [key] customer key of single item to retrieve
      * @returns {Promise.<{metadata: TYPE.ScriptMap, type: string}>} Promise
      */
-    static async retrieve(retrieveDir, _, __, ___, key) {
+    static async retrieve(retrieveDir, _, __, key) {
         await File.initPrettier('ssjs');
         return super.retrieveREST(retrieveDir, '/automation/v1/scripts/', null, null, key);
     }
@@ -128,8 +126,7 @@ class Script extends MetadataType {
      */
     static async preDeployTasks(metadata, dir) {
         // folder
-        metadata.categoryId = cache.searchForField('folder', metadata.r__folder_Path, 'Path', 'ID');
-        delete metadata.r__folder_Path;
+        super.setFolderId(metadata);
 
         // code
         metadata.script = await this._mergeCode(metadata, dir);

package/lib/metadataTypes/SetDefinition.js

@@ -15,11 +15,10 @@ class SetDefinition extends MetadataType {
      * @param {string} retrieveDir Directory where retrieved metadata directory will be saved
      * @param {void} [_] unused parameter
      * @param {void} [__] unused parameter
-     * @param {void} [___] unused parameter
      * @param {string} [key] customer key of single item to retrieve
      * @returns {Promise.<TYPE.MetadataTypeMapObj>} Promise
      */
-    static retrieve(retrieveDir, _, __, ___, key) {
+    static retrieve(retrieveDir, _, __, key) {
         return super.retrieveREST(
             retrieveDir,
             '/hub/v1/contacts/schema/setDefinitions',

package/lib/metadataTypes/TransactionalMessage.js

@@ -19,11 +19,10 @@ class TransactionalMessage extends MetadataType {
      * @param {string} retrieveDir Directory where retrieved metadata directory will be saved
      * @param {void} [_] unused parameter
      * @param {void} [__] unused parameter
-     * @param {void} [___] unused parameter
      * @param {string} [key] customer key of single item to retrieve
      * @returns {Promise.<TYPE.MetadataTypeMapObj>} Promise of metadata
      */
-    static async retrieve(retrieveDir, _, __, ___, key) {
+    static async retrieve(retrieveDir, _, __, key) {
         let keyList;
         const baseUri = '/messaging/v1/' + this.subType + '/definitions/';
         if (key) {
@@ -31,20 +30,16 @@ class TransactionalMessage extends MetadataType {
             keyList = [key];
         } else {
             // Retrieve all
-            const response = this.definition.restPagination
-                ? await this.client.rest.getBulk(baseUri)
-                : await this.client.rest.get(baseUri);
-            const parsed = this.parseResponseBody(response);
-            keyList = Object.keys(parsed).filter((item) => parsed[item].status !== 'Deleted');
-            const filteredCount = Object.keys(parsed).length - keyList.length;
-            if (filteredCount) {
-                Util.logger.info(
-                    ` - Filtered ${this.definition.type} with status 'deleted': ${filteredCount} (downloaded but not saved to disk)`
-                );
-            }
+            // * keep deleted items for caching (and to decide on update vs create)
+            const parsed = (
+                await this.retrieveREST(
+                    null,
+                    baseUri + (retrieveDir ? '?$filter=status%20neq%20deleted' : '')
+                )
+            ).metadata;
+            keyList = Object.keys(parsed);
         }
-
-        // get all sms with additional details not given by the list endpoint
+        // get all transactionalX items with additional details not given by the list endpoint
         const details = (
             await Promise.all(
                 keyList.map(async (key) => {
@@ -57,20 +52,17 @@ class TransactionalMessage extends MetadataType {
             )
         ).filter(Boolean);
         const parsed = this.parseResponseBody({ definitions: details });
+        let savedMetadata;
+        if (retrieveDir) {
+            // * retrieveDir is mandatory in this method as it is not used for caching (there is a seperate method for that)
+            savedMetadata = await this.saveResults(parsed, retrieveDir, null, null);
+            Util.logger.info(
+                `Downloaded: ${this.definition.type} (${Object.keys(savedMetadata).length})` +
+                    Util.getKeysString(key)
+            );
+        }
 
-        // * 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);
-        // defined colors for optionally printing the keys we filtered by
-        const color = {
-            reset: '\x1B[0m',
-            dim: '\x1B[2m',
-        };
-        Util.logger.info(
-            `Downloaded: ${this.definition.type} (${Object.keys(savedMetadata).length})` +
-                (key === null ? '' : ` ${color.dim}(Key: ${key})${color.reset}`)
-        );
-
-        return { metadata: savedMetadata, type: this.definition.type };
+        return { metadata: savedMetadata || parsed, type: this.definition.type };
     }
 
     /**
@@ -79,7 +71,10 @@ class TransactionalMessage extends MetadataType {
      * @returns {Promise.<TYPE.MetadataTypeMapObj>} Promise of metadata
      */
     static retrieveForCache() {
-        return super.retrieveREST(null, '/messaging/v1/' + this.subType + '/definitions/');
+        // the call to /messaging/v1/email/definitions/ does not return definitionId
+        // definitionId is required for resolving dependencies on interactions.
+        // we should therefore use the already defined retrieve method
+        return this.retrieve();
     }
     /**
      * Updates a single item
@@ -106,13 +101,11 @@ class TransactionalMessage extends MetadataType {
     /**
      * Delete a metadata item from the specified business unit
      *
-     * @param {TYPE.BuObject} buObject references credentials
      * @param {string} key Identifier of item
      * @returns {Promise.<boolean>} deletion success status
      */
-    static deleteByKey(buObject, key) {
+    static deleteByKey(key) {
         return super.deleteByKeyREST(
-            buObject,
             '/messaging/v1/' + this.subType + '/definitions/' + key,
             key,
             false

package/lib/metadataTypes/TransactionalSMS.js

@@ -17,16 +17,15 @@ class TransactionalSMS extends TransactionalMessage {
     /**
      * clean up after deleting a metadata item
      *
-     * @param {TYPE.BuObject} buObject references credentials
      * @param {string} customerKey Identifier of metadata item
      * @returns {void}
      */
-    static async postDeleteTasks(buObject, customerKey) {
+    static async postDeleteTasks(customerKey) {
         // delete local copy: retrieve/cred/bu/type/...json
         const fileName = File.normalizePath([
             this.properties.directories.retrieve,
-            buObject.credential,
-            buObject.businessUnit,
+            this.buObject.credential,
+            this.buObject.businessUnit,
             this.definition.type,
             `${customerKey}.${this.definition.type}-meta.`,
         ]);

package/lib/metadataTypes/TriggeredSendDefinition.js

@@ -5,6 +5,12 @@ const MetadataType = require('./MetadataType');
 const Util = require('../util/util');
 const cache = require('../util/cache');
 
+const cacheTypes = {
+    asset: require('./Asset'),
+    folder: require('./Folder'),
+    list: require('./List'),
+};
+
 /**
  * MessageSendActivity MetadataType
  *
@@ -17,26 +23,16 @@ class TriggeredSendDefinition extends MetadataType {
      * @param {string} retrieveDir Directory where retrieved metadata directory will be saved
      * @param {void} [_] unused parameter
      * @param {void} [__] unused parameter
-     * @param {void} [___] unused parameter
      * @param {string} [key] customer key of single item to retrieve
      * @returns {Promise.<TYPE.MetadataTypeMapObj>} Promise of metadata
      */
-    static retrieve(retrieveDir, _, __, ___, key) {
+    static retrieve(retrieveDir, _, __, key) {
         /** @type {TYPE.SoapRequestParams} */
         let requestParams = {
             filter: {
-                leftOperand: {
-                    // somehow that parameter controls visible (non deleted?) email send activities
-                    leftOperand: 'IsPlatformObject',
-                    operator: 'equals',
-                    rightOperand: false,
-                },
-                operator: 'AND',
-                rightOperand: {
-                    leftOperand: 'TriggeredSendStatus',
-                    operator: 'IN',
-                    rightOperand: ['New', 'Active', 'Inactive'], // New, Active=Running, Inactive=Paused, (Deleted)
-                },
+                leftOperand: 'TriggeredSendStatus',
+                operator: 'IN',
+                rightOperand: ['New', 'Active', 'Inactive', 'Moved', 'Canceled'], // New, Active=Running, Inactive=Paused, (Deleted)
             },
         };
         if (key) {
@@ -54,7 +50,7 @@ class TriggeredSendDefinition extends MetadataType {
             };
         }
 
-        return super.retrieveSOAP(retrieveDir, null, requestParams);
+        return super.retrieveSOAP(retrieveDir, requestParams);
     }
 
     /**
@@ -71,73 +67,75 @@ class TriggeredSendDefinition extends MetadataType {
      * Updates a single TSD.
      *
      * @param {TYPE.MetadataTypeItem} metadata single metadata entry
+     * @param {boolean} [handleOutside] if the API reponse is irregular this allows you to handle it outside of this generic method
      * @returns {Promise} Promise
      */
-    static update(metadata) {
+    static update(metadata, handleOutside) {
         // * in case of update and active definition, we need to pause first.
-        // * this should be done manually to not accidentally purge production queues
-        return super.updateSOAP(metadata);
+        // * this should be done manually to not accidentally pause production queues without restarting them
+        return super.updateSOAP(metadata, null, handleOutside);
     }
 
     /**
      * Delete a metadata item from the specified business unit
      *
-     * @param {TYPE.BuObject} buObject references credentials
      * @param {string} customerKey Identifier of data extension
      * @returns {Promise.<boolean>} deletion success status
      */
-    static deleteByKey(buObject, customerKey) {
-        return super.deleteByKeySOAP(buObject, customerKey, false);
+    static deleteByKey(customerKey) {
+        return super.deleteByKeySOAP(customerKey, false);
     }
 
     /**
-     * checks if the current metadata entry should be saved on retrieve or not
+     * manages post retrieve steps
      *
-     * @static
-     * @param {object} metadataEntry metadata entry
-     * @returns {boolean} if false, do not save
-     * @memberof MetadataType
+     * @param {TYPE.MetadataTypeItem} metadata a single query
+     * @returns {TYPE.MetadataTypeItem} Array with one metadata object and one query string
      */
-    static isFiltered(metadataEntry) {
+    static postRetrieveTasks(metadata) {
+        return this.parseMetadata(metadata);
+    }
+    /**
+     * generic script that retrieves the folder path from cache and updates the given metadata with it after retrieve
+     *
+     * @param {TYPE.MetadataTypeItem} metadata a single script activity definition
+     */
+    static setFolderPath(metadata) {
         try {
-            // get folder path to be able to filter journey-created TSDs
-            const folderPath = cache.searchForField(
+            metadata.r__folder_Path = cache.searchForField(
                 'folder',
-                metadataEntry.CategoryID,
+                metadata[this.definition.folderIdField],
                 'ID',
                 'Path'
             );
-
-            if (folderPath?.startsWith('Journey Builder Sends/')) {
-                // filter out any triggered sends that were auto-created by journeys
-                return true;
-            }
-        } catch {
-            // handle it in parseMetadata()
+            delete metadata[this.definition.folderIdField];
+        } catch (ex) {
+            Util.logger.verbose(
+                ` - skipping ${this.definition.type} '${metadata[this.definition.nameField]}' (${
+                    metadata[this.definition.keyField]
+                }): Could not find folder (${ex.message})`
+            );
+            throw ex;
         }
-        return false;
-    }
-
-    /**
-     * manages post retrieve steps
-     *
-     * @param {TYPE.MetadataTypeItem} metadata a single query
-     * @returns {TYPE.MetadataTypeItem} Array with one metadata object and one query string
-     */
-    static postRetrieveTasks(metadata) {
-        return this.parseMetadata(metadata);
     }
     /**
      * parses retrieved Metadata before saving
      *
      * @param {TYPE.MetadataTypeItem} metadata a single query activity definition
-     * @returns {TYPE.MetadataTypeItem} Array with one metadata object and one sql string
+     * @returns {TYPE.MetadataTypeItem | void} Array with one metadata object and one sql string
      */
     static parseMetadata(metadata) {
         // remove IsPlatformObject, always has to be 'false'
         delete metadata.IsPlatformObject;
         // folder
-        super.setFolderPath(metadata);
+        try {
+            this.setFolderPath(metadata);
+        } catch {
+            Util.logger.verbose(
+                ` - skipping ${this.definition.typeName} '${metadata.Name}'/'${metadata.CustomerKey}': Could not find folder.`
+            );
+            return;
+        }
 
         // email
         try {
@@ -164,9 +162,10 @@ class TriggeredSendDefinition extends MetadataType {
                 metadata.r__assetMessage_Key = contentBuilderEmailKey;
                 delete metadata.Email;
             } catch {
-                Util.logger.warn(
-                    ` - ${this.definition.typeName} '${metadata.Name}'/'${metadata.CustomerKey}': Could not find email with ID ${metadata.Email.ID} in Classic nor in Content Builder.`
+                Util.logger.verbose(
+                    ` - skipping ${this.definition.typeName} '${metadata.Name}'/'${metadata.CustomerKey}': Could not find email with ID ${metadata.Email.ID} in Classic nor in Content Builder.`
                 );
+                return;
             }
         }
         // List (optional)
@@ -175,9 +174,10 @@ class TriggeredSendDefinition extends MetadataType {
                 metadata.r__list_PathName = cache.getListPathName(metadata.List.ID, 'ID');
                 delete metadata.List;
             } catch (ex) {
-                Util.logger.warn(
-                    ` - ${this.definition.typeName} '${metadata.Name}'/'${metadata.CustomerKey}': ${ex.message}`
+                Util.logger.verbose(
+                    ` - skipping ${this.definition.typeName} '${metadata.Name}'/'${metadata.CustomerKey}': ${ex.message}`
                 );
+                return;
             }
         }
 
@@ -202,8 +202,7 @@ class TriggeredSendDefinition extends MetadataType {
         // re-add IsPlatformObject, required for visibility
         metadata.IsPlatformObject = false;
         // folder
-        metadata.CategoryID = cache.searchForField('folder', metadata.r__folder_Path, 'Path', 'ID');
-        delete metadata.r__folder_Path;
+        super.setFolderId(metadata);
         // email
         if (metadata.r__email_Name) {
             // classic
@@ -243,6 +242,183 @@ class TriggeredSendDefinition extends MetadataType {
 
         return metadata;
     }
+    /**
+     * TSD-specific refresh method that finds active TSDs and refreshes them
+     *
+     * @param {string[]} [keyArr] metadata keys
+     * @returns {Promise.<void>} -
+     */
+    static async refresh(keyArr) {
+        console.time('Time'); // eslint-disable-line no-console
+        let checkKey = true;
+        if (!keyArr) {
+            keyArr = await this._findRefreshableItems();
+            checkKey = false;
+        }
+        // then executes pause, publish, start on them.
+        const refreshList = [];
+        Util.logger.info(`Refreshing ${keyArr.length} ${this.definition.typeName}...`);
+        Util.logger.debug(`Refreshing keys: ${keyArr.join(', ')}`);
+        for (const key of keyArr) {
+            refreshList.push(this._refreshItem(key, checkKey));
+        }
+        const successCounter = (await Promise.all(refreshList)).filter(Boolean).length;
+        Util.logger.info(`Refreshed ${successCounter} of ${keyArr.length}`);
+        console.timeEnd('Time'); // eslint-disable-line no-console
+    }
+
+    /**
+     * helper for {@link refresh} that finds active TSDs on the server and filters it by the same rules that {@link retrieve} is using to avoid refreshing TSDs with broken dependencies
+     *
+     * @returns {Promise.<string[]>} keyArr
+     */
+    static async _findRefreshableItems() {
+        Util.logger.info('Finding refreshable items...');
+        // cache dependencies to test for broken links
+        // skip deprecated classic emails here, assuming they cannot be updated and hence are not relevant for {@link refresh}
+        const requiredCache = {
+            folder: [
+                'list',
+                'mysubs',
+                'suppression_list',
+                'publication',
+                'contextual_suppression_list',
+                'triggered_send',
+                'triggered_send_journeybuilder',
+            ],
+            asset: ['message'],
+            list: null,
+        };
+        for (const [type, subTypeArr] of Object.entries(requiredCache)) {
+            if (!cache.getCache()?.[type]) {
+                Util.logger.info(` - Caching dependent Metadata: ${type}`);
+                Util.logSubtypes(subTypeArr);
+                cacheTypes[type].client = this.client;
+                cacheTypes[type].buObject = this.buObject;
+                cacheTypes[type].properties = this.properties;
+
+                const result = await cacheTypes[type].retrieveForCache(null, subTypeArr);
+                cache.setMetadata(type, result.metadata);
+            }
+        }
+        //  cache ACTIVE triggeredSends from the server
+        /** @type {TYPE.SoapRequestParams} */
+        const requestParams = {
+            filter: {
+                leftOperand: 'TriggeredSendStatus',
+                operator: 'IN',
+                rightOperand: ['dummy', 'Active'], // using equals does not work for this field for an unknown reason and IN requires at least 2 values, hence the 'dummy' entry
+            },
+        };
+        const metadata = (await super.retrieveSOAP(null, requestParams)).metadata;
+        const keyArr = Object.keys(metadata).filter((key) => {
+            const test = this.postRetrieveTasks(metadata[key]);
+            return test?.CustomerKey || false;
+        });
+        Util.logger.info(`Found ${keyArr.length} refreshable items.`);
+        return keyArr;
+    }
+
+    /**
+     * helper for {@link refresh} that pauses, publishes and starts a triggered send
+     *
+     * @param {string} key external key of triggered send item
+     * @param {boolean} checkKey whether to check if key exists on the server
+     * @returns {Promise.<boolean>} true if refresh was successful
+     */
+    static async _refreshItem(key, checkKey) {
+        const item = {};
+        let test;
+        item[this.definition.keyField] = key;
+        // check triggeredSend-key exists on the server AND its status==ACTIVE
+        if (checkKey) {
+            /** @type {TYPE.SoapRequestParams} */
+            const requestParams = {
+                filter: {
+                    leftOperand: 'CustomerKey',
+                    operator: 'equals',
+                    rightOperand: key,
+                },
+            };
+            try {
+                test = (
+                    await super.retrieveSOAP(null, requestParams, [
+                        'CustomerKey',
+                        'TriggeredSendStatus',
+                    ])
+                )?.metadata;
+            } catch (ex) {
+                const errorMsg = super.getSOAPErrorMsg(ex);
+                Util.logger.error(` ☇ skipping ${this.definition.typeName}: ${key} - ${errorMsg}}`);
+                return false;
+            }
+            if (!test[key]) {
+                Util.logger.error(
+                    ` ☇ skipping ${this.definition.typeName}: ${key} - not found on server`
+                );
+                return false;
+            }
+            if (test[key].TriggeredSendStatus !== 'Active') {
+                Util.logger.error(
+                    ` ☇ skipping ${this.definition.typeName}: ${key} - refresh only needed for running entries (TriggeredSendStatus=Active)`
+                );
+                return false;
+            }
+        }
+
+        // pause
+        try {
+            item.TriggeredSendStatus = 'Inactive';
+            test = await this.update(item, true);
+            if (test.OverallStatus !== 'OK') {
+                throw new Error(test.Results[0].StatusMessage);
+            }
+            delete item.TriggeredSendStatus;
+            Util.logger.info(` - paused ${this.definition.typeName}: ${key}`);
+        } catch (ex) {
+            const errorMsg = super.getSOAPErrorMsg(ex);
+
+            Util.logger.error(
+                ` - failed to pause ${this.definition.typeName}: ${key} - ${errorMsg}`
+            );
+            return false;
+        }
+
+        // publish
+        try {
+            item.RefreshContent = 'true';
+            test = await this.update(item, true);
+            if (test.OverallStatus !== 'OK') {
+                throw new Error(test.Results[0].StatusMessage);
+            }
+            delete item.RefreshContent;
+            Util.logger.info(` - published ${this.definition.typeName}: ${key}`);
+        } catch (ex) {
+            const errorMsg = super.getSOAPErrorMsg(ex);
+            Util.logger.error(
+                ` - failed to publish ${this.definition.typeName}: ${key} - ${errorMsg}`
+            );
+            return false;
+        }
+
+        // start
+        try {
+            item.TriggeredSendStatus = 'Active';
+            test = await this.update(item, true);
+            if (test.OverallStatus !== 'OK') {
+                throw new Error(test.Results[0].StatusMessage);
+            }
+            delete item.RefreshContent;
+            Util.logger.info(` - started ${this.definition.typeName}: ${key}`);
+        } catch (ex) {
+            const errorMsg = super.getSOAPErrorMsg(ex);
+            Util.logger.error(
+                ` - failed to publish ${this.definition.typeName}: ${key} - ${errorMsg}`
+            );
+            return false;
+        }
+        return true;
+    }
 }
 
 // Assign definition to static attributes