mcdev 7.3.1 → 7.4.1

package/lib/metadataTypes/Journey.js

@@ -185,7 +185,7 @@ class Journey extends MetadataType {
             // if the interaction does not exist, the API returns an error code which would otherwise bring execution to a hold
             if (
                 [
-                    'Journey matching key not found.',
+                    'Interaction matching key not found.',
                     'Must provide a valid ID or Key parameter',
                 ].includes(ex.message)
             ) {
@@ -419,6 +419,7 @@ class Journey extends MetadataType {
                             metadata.triggers[0].type,
                             metadata.triggers[0].configurationArguments,
                             metadata.key,
+                            metadata.status === 'Published',
                             this.definition.type
                         );
                     } catch (ex) {
@@ -562,7 +563,6 @@ class Journey extends MetadataType {
             switch (activity.type) {
                 case 'EMAILV2': {
                     // triggeredSend + email+asset
-                    // TODO email / asset
                     const configurationArguments = activity.configurationArguments;
                     if (configurationArguments) {
                         try {
@@ -630,49 +630,79 @@ class Journey extends MetadataType {
                                 'triggeredSend',
                                 triggeredSend.r__triggeredSend_key
                             );
-                            triggeredSend.emailId = linkedTS?.Email?.ID;
-                            triggeredSend.dynamicEmailSubject = linkedTS.DynamicEmailSubject;
-                            triggeredSend.emailSubject = linkedTS.EmailSubject;
-                            triggeredSend.bccEmail = linkedTS.BccEmail;
-                            triggeredSend.isMultipart = linkedTS.IsMultipart;
-                            triggeredSend.autoAddSubscribers = linkedTS.AutoAddSubscribers;
-                            triggeredSend.autoUpdateSubscribers = linkedTS.AutoUpdateSubscribers;
-                            triggeredSend.isTrackingClicks = !linkedTS.SuppressTracking;
-                            // from name & email are set in the senderProfile, not in the triggeredSend
-                            // triggeredSend.fromName = linkedTS.FromName;
-                            // triggeredSend.fromAddress = linkedTS.FromAddress;
-
-                            if (linkedTS.SenderProfile?.CustomerKey) {
-                                try {
-                                    const spKey = cache.searchForField(
-                                        'senderProfile',
-                                        linkedTS.SenderProfile.ObjectID,
-                                        'ObjectID',
-                                        'CustomerKey'
-                                    );
-                                    triggeredSend.r__senderProfile_key = spKey;
-                                    delete triggeredSend.senderProfileId;
-                                } catch (ex) {
-                                    Util.logger.warn(
-                                        ` - triggeredSend ${linkedTS.CustomerKey}: ${ex.message} (senderProfile key ${linkedTS.SenderProfile.CustomerKey})`
-                                    );
+                            if (linkedTS) {
+                                triggeredSend.emailId = linkedTS.Email?.ID;
+                                triggeredSend.dynamicEmailSubject = linkedTS.DynamicEmailSubject;
+                                triggeredSend.emailSubject = linkedTS.EmailSubject;
+                                // only the bccEmail field can be retrieved for triggeredSends, not the ccEmail field; for some reason BccEmail can be retrieved but does not return a value even if stored correctly in the journey.
+                                // triggeredSend.bccEmail = linkedTS.BccEmail;
+                                triggeredSend.isMultipart = linkedTS.IsMultipart;
+                                triggeredSend.autoAddSubscribers = linkedTS.AutoAddSubscribers;
+                                triggeredSend.autoUpdateSubscribers =
+                                    linkedTS.AutoUpdateSubscribers;
+                                triggeredSend.isTrackingClicks = !linkedTS.SuppressTracking;
+                                // from name & email are set in the senderProfile, not in the triggeredSend
+                                // triggeredSend.fromName = linkedTS.FromName;
+                                // triggeredSend.fromAddress = linkedTS.FromAddress;
+
+                                if (linkedTS.List?.ID) {
+                                    triggeredSend.publicationListId = linkedTS.List.ID;
+                                } else if (linkedTS.r__list_PathName) {
+                                    delete triggeredSend.publicationListId;
+                                    triggeredSend.r__list_PathName = {
+                                        publicationList: linkedTS.r__list_PathName,
+                                    };
                                 }
-                            }
-                            // send classification
-                            if (linkedTS.SendClassification?.CustomerKey) {
-                                try {
-                                    const scKey = cache.searchForField(
-                                        'sendClassification',
-                                        linkedTS.SendClassification.ObjectID,
-                                        'ObjectID',
-                                        'CustomerKey'
-                                    );
-                                    triggeredSend.r__sendClassification_key = scKey;
-                                    delete triggeredSend.sendClassificationId;
-                                } catch (ex) {
-                                    Util.logger.warn(
-                                        ` - triggeredSend ${linkedTS.CustomerKey}: ${ex.message} (sendClassification key ${linkedTS.SendClassification.CustomerKey})`
-                                    );
+                                if (linkedTS.SenderProfile?.CustomerKey) {
+                                    try {
+                                        const spKey = cache.searchForField(
+                                            'senderProfile',
+                                            linkedTS.SenderProfile.ObjectID,
+                                            'ObjectID',
+                                            'CustomerKey'
+                                        );
+                                        triggeredSend.r__senderProfile_key = spKey;
+                                        delete triggeredSend.senderProfileId;
+                                    } catch (ex) {
+                                        Util.logger.warn(
+                                            ` - triggeredSend ${linkedTS.CustomerKey}: ${ex.message} (senderProfile key ${linkedTS.SenderProfile.CustomerKey})`
+                                        );
+                                    }
+                                } else if (linkedTS.r__senderProfile_key) {
+                                    triggeredSend.r__senderProfile_key =
+                                        linkedTS.r__senderProfile_key;
+                                }
+                                // send classification
+                                if (linkedTS.SendClassification?.CustomerKey) {
+                                    try {
+                                        const scKey = cache.searchForField(
+                                            'sendClassification',
+                                            linkedTS.SendClassification.ObjectID,
+                                            'ObjectID',
+                                            'CustomerKey'
+                                        );
+                                        triggeredSend.r__sendClassification_key = scKey;
+                                        delete triggeredSend.sendClassificationId;
+                                    } catch (ex) {
+                                        Util.logger.warn(
+                                            ` - triggeredSend ${linkedTS.CustomerKey}: ${ex.message} (sendClassification key ${linkedTS.SendClassification.CustomerKey})`
+                                        );
+                                    }
+                                } else if (linkedTS.r__sendClassification_key) {
+                                    triggeredSend.r__sendClassification_key =
+                                        linkedTS.r__sendClassification_key;
+                                }
+                                if (linkedTS.c__priority) {
+                                    delete triggeredSend.priority;
+                                    triggeredSend.c__priority = linkedTS.c__priority;
+                                }
+                                if (linkedTS.Email?.ID) {
+                                    triggeredSend.emailId = linkedTS.Email.ID;
+                                } else if (linkedTS.r__asset_key) {
+                                    delete triggeredSend.emailId;
+                                    triggeredSend.r__asset_name_readOnly =
+                                        linkedTS.r__asset_name_readOnly;
+                                    triggeredSend.r__asset_key = linkedTS.r__asset_key;
                                 }
                             }
                         } else if (triggeredSend.id) {
@@ -706,8 +736,15 @@ class Journey extends MetadataType {
                             delete triggeredSend.key;
                         }
 
+                        triggeredSend.ccEmail = triggeredSend.ccEmail
+                            .split(';')
+                            .filter((el) => el !== '');
+                        triggeredSend.bccEmail = triggeredSend.bccEmail
+                            .split(';')
+                            .filter((el) => el !== '');
+
                         // List (optional)
-                        triggeredSend.r__list_PathName = {};
+                        triggeredSend.r__list_PathName ||= {};
                         if (triggeredSend.publicationListId) {
                             try {
                                 triggeredSend.r__list_PathName.publicationList =
@@ -827,39 +864,45 @@ class Journey extends MetadataType {
                             delete triggeredSend.priority;
                         }
                         // email
-                        try {
-                            // content builder
-                            triggeredSend.r__asset_name_readOnly = cache.searchForField(
-                                'asset',
-                                triggeredSend.emailId,
-                                'legacyData.legacyId',
-                                'name'
-                            );
-                            triggeredSend.r__asset_key = cache.searchForField(
-                                'asset',
-                                triggeredSend.emailId,
-                                'legacyData.legacyId',
-                                'customerKey'
-                            );
-                            delete triggeredSend.emailId;
-                        } catch {
+                        if (triggeredSend.emailId) {
                             try {
-                                // classic
-                                triggeredSend.r__email_name = cache.searchForField(
-                                    'email',
+                                // content builder
+                                triggeredSend.r__asset_name_readOnly = cache.searchForField(
+                                    'asset',
+                                    triggeredSend.emailId,
+                                    'legacyData.legacyId',
+                                    'name'
+                                );
+                                triggeredSend.r__asset_key = cache.searchForField(
+                                    'asset',
                                     triggeredSend.emailId,
-                                    'ID',
-                                    'Name'
+                                    'legacyData.legacyId',
+                                    'customerKey'
                                 );
                                 delete triggeredSend.emailId;
                             } catch {
-                                Util.logger.warn(
-                                    ` - ${this.definition.type} '${metadata[this.definition.nameField]}' (${
-                                        metadata[this.definition.keyField]
-                                    }): Could not find email with ID ${triggeredSend.emailId} in Classic nor in Content Builder.`
-                                );
+                                try {
+                                    // classic
+                                    triggeredSend.r__email_name = cache.searchForField(
+                                        'email',
+                                        triggeredSend.emailId,
+                                        'ID',
+                                        'Name'
+                                    );
+                                    delete triggeredSend.emailId;
+                                } catch {
+                                    Util.logger.warn(
+                                        ` - ${this.definition.type} '${metadata[this.definition.nameField]}' (${
+                                            metadata[this.definition.keyField]
+                                        }): Could not find email with ID ${triggeredSend.emailId} in Classic nor in Content Builder.`
+                                    );
+                                }
                             }
                         }
+
+                        // sort attributes of triggeredSend alphabetically to allow for easier pull request reviews
+                        configurationArguments.triggeredSend =
+                            Util.sortObjectAttributes(triggeredSend);
                     }
                     break;
                 }
@@ -978,12 +1021,10 @@ class Journey extends MetadataType {
                     break;
                 }
             }
-            // TODO: Filters / activities[].type === 'MULTICRITERIADECISION'
-            // - activities[].arguments.filterResult
-            // - activities[].arguments.configurationArguments.criteria
-
-            // TODO: wait activity / activities[].type === 'WAIT'
         }
+
+        // apply sorting by activity key to work around the API shuffling activities around
+        metadata.activities = metadata.activities.sort((a, b) => a.key.localeCompare(b.key));
     }
 
     /**
@@ -1190,6 +1231,15 @@ class Journey extends MetadataType {
                             delete triggeredSend.r__triggeredSend_key;
                         }
 
+                        triggeredSend.ccEmail =
+                            typeof triggeredSend.ccEmail === 'string'
+                                ? triggeredSend.ccEmail
+                                : triggeredSend.ccEmail.join(';');
+                        triggeredSend.bccEmail =
+                            typeof triggeredSend.bccEmail === 'string'
+                                ? triggeredSend.bccEmail
+                                : triggeredSend.bccEmail.join(';');
+
                         // List (optional)
                         if (triggeredSend.r__list_PathName) {
                             if (triggeredSend.r__list_PathName.publicationList) {
@@ -1444,11 +1494,16 @@ class Journey extends MetadataType {
             if (triggeredSend) {
                 // the following is very similar but not equal to the variables in TriggeredSend.js
                 try {
-                    triggeredSend.bccEmail = ReplaceCbReference.replaceReference(
-                        triggeredSend.bccEmail,
+                    let bccEmail =
+                        typeof triggeredSend.bccEmail === 'string'
+                            ? triggeredSend.bccEmail
+                            : triggeredSend.bccEmail.join(';');
+                    bccEmail = ReplaceCbReference.replaceReference(
+                        bccEmail,
                         parentName,
                         findAssetKeys
                     );
+                    triggeredSend.bccEmail = bccEmail.split(';').filter((el) => el !== '');
                     changes = true;
                 } catch (ex) {
                     if (ex.code !== 200) {
@@ -1456,11 +1511,16 @@ class Journey extends MetadataType {
                     }
                 }
                 try {
-                    triggeredSend.ccEmail = ReplaceCbReference.replaceReference(
-                        triggeredSend.ccEmail,
+                    let ccEmail =
+                        typeof triggeredSend.ccEmail === 'string'
+                            ? triggeredSend.ccEmail
+                            : triggeredSend.ccEmail.join(';');
+                    ccEmail = ReplaceCbReference.replaceReference(
+                        ccEmail,
                         parentName,
                         findAssetKeys
                     );
+                    triggeredSend.ccEmail = ccEmail.split(';').filter((el) => el !== '');
                     changes = true;
                 } catch (ex) {
                     if (ex.code !== 200) {
@@ -1691,7 +1751,7 @@ class Journey extends MetadataType {
                         ); // payload is empty for this request
                         if (response.statusUrl && response.statusId) {
                             Util.logger.info(
-                                ` - ${this.definition.type} queued for publishing : ${key}/${version}`
+                                ` - ${this.definition.type} queued for publishing: ${journey[this.definition.keyField]}/${version} / ${journey[this.definition.nameField]}`
                             );
                             statusUrl = response.statusUrl;
                         } else {
@@ -1704,7 +1764,12 @@ class Journey extends MetadataType {
 
                             await Util.sleep(1000);
                             executedKeyArr.push(
-                                await this._checkPublishStatus(statusUrl, key, spinner)
+                                await this._checkPublishStatus(
+                                    statusUrl,
+                                    journey[this.definition.keyField],
+                                    journey[this.definition.nameField],
+                                    spinner
+                                )
                             );
                         } else {
                             // no guarantees if the journey was actually published
@@ -1804,35 +1869,44 @@ class Journey extends MetadataType {
      * helper for {@link Journey.publish}
      *
      * @param {string} statusUrl URL to check the status of the publish request
-     * @param {string} key key or id for log messages
-     * @param {any} spinner key or id for log messages
+     * @param {string} key journey-key or id for log messages
+     * @param {string} name journey-name for log messages
+     * @param {import('yocto-spinner').Spinner} spinner reference to spinner to allow stopping it when done
      * @param {number} [tries] number of tries used to check the status
      * @returns {Promise.<string>} key of the item that was published successfully
      */
-    static async _checkPublishStatus(statusUrl, key, spinner, tries = 1) {
+    static async _checkPublishStatus(statusUrl, key, name, spinner, tries = 1) {
         try {
             const response = await this.client.rest.get(statusUrl);
             switch (response.status) {
                 case 'PublishCompleted': {
                     spinner.success('done.');
-                    Util.logger.info(` - ${this.definition.type} ${key}: publishing succeeded`);
+                    Util.logger.info(` - published ${this.definition.type}: ${key} / ${name}`);
                     this._showPublishStatusDetails(response);
                     return key;
                 }
                 case 'PublishInProcess': {
                     Util.logger.debug(
-                        ` - ${this.definition.type} ${key}: publishing still in progress`
+                        ` - publishing ${this.definition.type} still in progress: ${key} / ${name}`
                     );
                     if (tries < 50) {
                         await (tries < 10 ? Util.sleep(2000) : Util.sleep(5000));
-                        return await this._checkPublishStatus(statusUrl, key, spinner, tries + 1);
+                        return await this._checkPublishStatus(
+                            statusUrl,
+                            key,
+                            name,
+                            spinner,
+                            tries + 1
+                        );
                     } else {
                         return;
                     }
                 }
                 case 'Error': {
                     spinner.success('failed.');
-                    Util.logger.error(` - ${this.definition.type} ${key}: publishing failed.`);
+                    Util.logger.error(
+                        ` - publishing ${this.definition.type} failed: ${key} / ${name}`
+                    );
                     this._showPublishStatusDetails(response);
                     return;
                 }
@@ -1969,6 +2043,50 @@ class Journey extends MetadataType {
 
         return stoppedKeyArr;
     }
+    /**
+     * resumes selected journey versions
+     *
+     * @param {string[]} keyArr customerkey of the metadata
+     * @returns {Promise.<string[]>} Returns list of keys that were paused
+     */
+    static async execute(keyArr) {
+        let version;
+        const endpoint = '/interaction/v1/interactions/resume/';
+        const resumedKeyArr = [];
+        const apiLimit = pLimit(20);
+        const journeyCache = await this.retrieveForCache();
+
+        await Promise.allSettled(
+            keyArr.map((key) =>
+                apiLimit(async () => {
+                    [key, version] = key.split('/');
+                    if (journeyCache.metadata[key]) {
+                        version ||= journeyCache.metadata[key].version;
+                        try {
+                            await this.client.rest.post(
+                                endpoint +
+                                    journeyCache.metadata[key].id +
+                                    (version === '*'
+                                        ? '?allVersions=true'
+                                        : `?versionNumber=${version}`),
+                                {}
+                            );
+                            Util.logger.info(
+                                ` - Resumed ${this.definition.type} ${key}/${version}`
+                            );
+                            resumedKeyArr.push(key);
+                        } catch (ex) {
+                            Util.logger.error(
+                                ` - Resuming ${this.definition.type} ${key} failed: ${ex.message}`
+                            );
+                        }
+                    }
+                })
+            )
+        );
+
+        return resumedKeyArr;
+    }
 }
 
 // Assign definition to static attributes