mcdev 6.0.2 → 7.0.0

package/lib/metadataTypes/TriggeredSend.js

@@ -1,12 +1,25 @@
 'use strict';
 
-import TYPE from '../../types/mcdev.d.js';
 import MetadataType from './MetadataType.js';
 import { Util } from '../util/util.js';
 import cache from '../util/cache.js';
 import asset from './Asset.js';
 import folder from './Folder.js';
 import list from './List.js';
+import ReplaceCbReference from '../util/replaceContentBlockReference.js';
+
+/**
+ * @typedef {import('../../types/mcdev.d.js').BuObject} BuObject
+ * @typedef {import('../../types/mcdev.d.js').CodeExtract} CodeExtract
+ * @typedef {import('../../types/mcdev.d.js').CodeExtractItem} CodeExtractItem
+ * @typedef {import('../../types/mcdev.d.js').MetadataTypeItem} MetadataTypeItem
+ * @typedef {import('../../types/mcdev.d.js').MetadataTypeItemDiff} MetadataTypeItemDiff
+ * @typedef {import('../../types/mcdev.d.js').MetadataTypeItemObj} MetadataTypeItemObj
+ * @typedef {import('../../types/mcdev.d.js').MetadataTypeMap} MetadataTypeMap
+ * @typedef {import('../../types/mcdev.d.js').MetadataTypeMapObj} MetadataTypeMapObj
+ * @typedef {import('../../types/mcdev.d.js').SoapRequestParams} SoapRequestParams
+ * @typedef {import('../../types/mcdev.d.js').TemplateMap} TemplateMap
+ */
 
 /**
  * MessageSendActivity MetadataType
@@ -18,13 +31,13 @@ class TriggeredSend extends MetadataType {
      * Retrieves SOAP based metadata of metadata type into local filesystem. executes callback with retrieved metadata
      *
      * @param {string} retrieveDir Directory where retrieved metadata directory will be saved
-     * @param {void} [_] unused parameter
-     * @param {void} [__] unused parameter
+     * @param {void | string[]} [_] unused parameter
+     * @param {void | string[]} [__] unused parameter
      * @param {string} [key] customer key of single item to retrieve
-     * @returns {Promise.<TYPE.MetadataTypeMapObj>} Promise of metadata
+     * @returns {Promise.<MetadataTypeMapObj>} Promise of metadata
      */
     static retrieve(retrieveDir, _, __, key) {
-        /** @type {TYPE.SoapRequestParams} */
+        /** @type {SoapRequestParams} */
         let requestParams = {
             filter: {
                 leftOperand: 'TriggeredSendStatus',
@@ -53,7 +66,7 @@ class TriggeredSend extends MetadataType {
     /**
      * Create a single TSD.
      *
-     * @param {TYPE.MetadataTypeItem} metadata single metadata entry
+     * @param {MetadataTypeItem} metadata single metadata entry
      * @returns {Promise} Promise
      */
     static create(metadata) {
@@ -63,7 +76,7 @@ class TriggeredSend extends MetadataType {
     /**
      * Updates a single TSD.
      *
-     * @param {TYPE.MetadataTypeItem} metadata single metadata entry
+     * @param {MetadataTypeItem} metadata single metadata entry
      * @returns {Promise} Promise
      */
     static update(metadata) {
@@ -85,8 +98,8 @@ class TriggeredSend extends MetadataType {
     /**
      * parses retrieved Metadata before saving
      *
-     * @param {TYPE.MetadataTypeItem} metadata a single item
-     * @returns {TYPE.MetadataTypeItem | void} Array with one metadata object and one sql string
+     * @param {MetadataTypeItem} metadata a single item
+     * @returns {MetadataTypeItem | void} Array with one metadata object and one sql string
      */
     static postRetrieveTasks(metadata) {
         // remove IsPlatformObject, always has to be 'false'
@@ -101,30 +114,29 @@ class TriggeredSend extends MetadataType {
             // do not save this TSD because it would not be visible in the user interface
             return;
         }
-
         // email
         try {
-            // classic
-            const classicEmail = cache.searchForField('email', metadata.Email.ID, 'ID', 'Name');
-            metadata.r__email_Name = classicEmail;
+            // content builder
+            const contentBuilderEmailName = cache.searchForField(
+                'asset',
+                metadata.Email.ID,
+                'legacyData.legacyId',
+                'name'
+            );
+            metadata.r__asset_name_readOnly = contentBuilderEmailName;
+            const contentBuilderEmailKey = cache.searchForField(
+                'asset',
+                metadata.Email.ID,
+                'legacyData.legacyId',
+                'customerKey'
+            );
+            metadata.r__asset_key = contentBuilderEmailKey;
             delete metadata.Email;
         } catch {
             try {
-                // content builder
-                const contentBuilderEmailName = cache.searchForField(
-                    'asset',
-                    metadata.Email.ID,
-                    'legacyData.legacyId',
-                    'name'
-                );
-                metadata.r__assetMessage_Name_readOnly = contentBuilderEmailName;
-                const contentBuilderEmailKey = cache.searchForField(
-                    'asset',
-                    metadata.Email.ID,
-                    'legacyData.legacyId',
-                    'customerKey'
-                );
-                metadata.r__assetMessage_Key = contentBuilderEmailKey;
+                // classic
+                const classicEmail = cache.searchForField('email', metadata.Email.ID, 'ID', 'Name');
+                metadata.r__email_name = classicEmail;
                 delete metadata.Email;
             } catch {
                 Util.logger.verbose(
@@ -133,6 +145,15 @@ class TriggeredSend extends MetadataType {
                 // save this TSD because it could be fixed by the user or potentially restarted without a fix; also, it might be used by a journey
             }
         }
+        // message priority
+        if (metadata.Priority) {
+            metadata.c__priority = Util.inverseGet(
+                this.definition.priorityMapping,
+                metadata.Priority
+            );
+            delete metadata.Priority;
+        }
+
         // List (optional)
         if (metadata.List) {
             try {
@@ -146,13 +167,48 @@ class TriggeredSend extends MetadataType {
             }
         }
 
+        // sender profile
+        if (metadata.SenderProfile?.CustomerKey) {
+            try {
+                cache.searchForField(
+                    'senderProfile',
+                    metadata.SenderProfile.CustomerKey,
+                    'CustomerKey',
+                    'CustomerKey'
+                );
+                metadata.r__senderProfile_key = metadata.SenderProfile.CustomerKey;
+                delete metadata.SenderProfile;
+            } catch (ex) {
+                Util.logger.warn(
+                    ` - ${this.definition.type} ${metadata.CustomerKey}: ${ex.message}`
+                );
+            }
+        }
+        // send classification
+        if (metadata.SendClassification?.CustomerKey) {
+            try {
+                cache.searchForField(
+                    'sendClassification',
+                    metadata.SendClassification.CustomerKey,
+                    'CustomerKey',
+                    'CustomerKey'
+                );
+                metadata.r__sendClassification_key = metadata.SendClassification.CustomerKey;
+                delete metadata.SendClassification;
+            } catch (ex) {
+                Util.logger.warn(
+                    ` - ${this.definition.type} ${metadata.CustomerKey}: ${ex.message}`
+                );
+            }
+        }
+
         return metadata;
     }
     /**
      * prepares a TSD for deployment
      *
-     * @param {TYPE.MetadataTypeItem} metadata of a single TSD
-     * @returns {TYPE.MetadataTypeItem} metadata object
+     * @param {MetadataTypeItem} metadata of a single TSD
+     * @returns {Promise.<MetadataTypeItem>} metadata object
      */
     static async preDeployTasks(metadata) {
         const cachedVersion = cache.getByKey(this.definition.type, metadata.CustomerKey);
@@ -169,30 +225,35 @@ class TriggeredSend extends MetadataType {
         // folder
         super.setFolderId(metadata);
         // email
-        if (metadata.r__email_Name) {
+        if (metadata.r__email_name) {
             // classic
             metadata.Email = {
-                ID: cache.searchForField('email', metadata.r__email_Name, 'Name', 'ID'),
+                ID: cache.searchForField('email', metadata.r__email_name, 'Name', 'ID'),
             };
-            delete metadata.r__email_Name;
-        } else if (metadata.r__assetMessage_Key) {
+            delete metadata.r__email_name;
+        } else if (metadata.r__asset_key) {
             // content builder
-            // * this ignores r__assetMessage_Name_readOnly on purpose as that is only unique per parent folder but useful during PR reviews
+            // * this ignores r__asset_name_readOnly on purpose as that is only unique per parent folder but useful during PR reviews
             metadata.Email = {
                 ID: cache.searchForField(
                     'asset',
-                    metadata.r__assetMessage_Key,
+                    metadata.r__asset_key,
                     'customerKey',
                     'legacyData.legacyId'
                 ),
             };
-            delete metadata.r__assetMessage_Key;
-            delete metadata.r__assetMessage_Name_readOnly;
+            delete metadata.r__asset_key;
+            delete metadata.r__asset_name_readOnly;
         } else if (metadata?.Email?.ID) {
             throw new Error(
-                `r__assetMessage_Key / r__email_Name not defined but instead found Email.ID. Please try re-retrieving this TSD from your BU.`
+                `r__asset_key / r__email_name not defined but instead found Email.ID. Please try re-retrieving this TSD from your BU.`
             );
         }
+        // message priority
+        if (metadata.c__priority) {
+            metadata.Priority = this.definition.priorityMapping[metadata.c__priority];
+            delete metadata.c__priority;
+        }
         // get List (optional)
         if (metadata.r__list_PathName) {
             metadata.List = {
@@ -204,6 +265,32 @@ class TriggeredSend extends MetadataType {
                 `r__list_PathName not defined but instead found List.ID. Please try re-retrieving this TSD from your BU.`
             );
         }
+        // sender profile
+        if (metadata.r__senderProfile_key) {
+            cache.searchForField(
+                'senderProfile',
+                metadata.r__senderProfile_key,
+                'CustomerKey',
+                'CustomerKey'
+            );
+            metadata.SenderProfile = {
+                CustomerKey: metadata.r__senderProfile_key,
+            };
+            delete metadata.r__senderProfile_key;
+        }
+        // send classification
+        if (metadata.r__sendClassification_key) {
+            cache.searchForField(
+                'sendClassification',
+                metadata.r__sendClassification_key,
+                'CustomerKey',
+                'CustomerKey'
+            );
+            metadata.SendClassification = {
+                CustomerKey: metadata.r__sendClassification_key,
+            };
+            delete metadata.r__sendClassification_key;
+        }
 
         return metadata;
     }
@@ -235,7 +322,7 @@ class TriggeredSend extends MetadataType {
     /**
      * helper for {@link TriggeredSend.refresh} that extracts the keys from the TSD item map and eli
      *
-     * @param {TYPE.MetadataTypeMapObj} metadata TSD item map
+     * @param {MetadataTypeMap} metadata TSD item map
      * @returns {Promise.<string[]>} keyArr
      */
     static async getKeysForValidTSDs(metadata) {
@@ -250,7 +337,7 @@ class TriggeredSend extends MetadataType {
      * helper for {@link TriggeredSend.refresh} that finds active TSDs on the server and filters it by the same rules that {@link TriggeredSend.retrieve} is using to avoid refreshing TSDs with broken dependencies
      *
      * @param {boolean} [assetLoaded] if run after Asset.deploy via --refresh option this will skip caching assets
-     * @returns {Promise.<TYPE.MetadataTypeMapObj>} Promise of TSD item map
+     * @returns {Promise.<MetadataTypeMapObj>} Promise of TSD item map
      */
     static async findRefreshableItems(assetLoaded = false) {
         Util.logger.info('Finding refreshable items...');
@@ -294,7 +381,7 @@ class TriggeredSend extends MetadataType {
             }
         }
         //  cache ACTIVE triggeredSends from the server
-        /** @type {TYPE.SoapRequestParams} */
+        /** @type {SoapRequestParams} */
         const requestParams = {
             filter: {
                 leftOperand: 'TriggeredSendStatus',
@@ -318,7 +405,7 @@ class TriggeredSend extends MetadataType {
         item[this.definition.keyField] = key;
         // check triggeredSend-key exists on the server AND its status==ACTIVE
         if (checkKey) {
-            /** @type {TYPE.SoapRequestParams} */
+            /** @type {SoapRequestParams} */
             const requestParams = {
                 filter: {
                     leftOperand: 'CustomerKey',
@@ -405,6 +492,67 @@ class TriggeredSend extends MetadataType {
         }
         return true;
     }
+    /**
+     *
+     * @param {MetadataTypeItem} item single metadata item
+     * @returns {Promise.<MetadataTypeItem>} key of the item that was updated
+     */
+    static async replaceCbReference(item) {
+        const parentName = `${this.definition.type} ${item[this.definition.keyField]}`;
+        let changes = false;
+        let error;
+
+        // *** type specific logic ***
+        try {
+            item.FromName = ReplaceCbReference.replaceReference(item.FromName, parentName);
+            changes = true;
+        } catch (ex) {
+            if (ex.code !== 200) {
+                error = ex;
+            }
+        }
+        try {
+            item.FromAddress = ReplaceCbReference.replaceReference(item.FromAddress, parentName);
+            changes = true;
+        } catch (ex) {
+            if (ex.code !== 200) {
+                error = ex;
+            }
+        }
+        try {
+            item.EmailSubject = ReplaceCbReference.replaceReference(item.EmailSubject, parentName);
+            changes = true;
+        } catch (ex) {
+            if (ex.code !== 200) {
+                error = ex;
+            }
+        }
+        try {
+            item.DynamicEmailSubject = ReplaceCbReference.replaceReference(
+                item.DynamicEmailSubject,
+                parentName
+            );
+            changes = true;
+        } catch (ex) {
+            if (ex.code !== 200) {
+                error = ex;
+            }
+        }
+        if (error) {
+            throw error;
+        }
+
+        if (!changes) {
+            const ex = new Error('No changes made to the code.');
+            ex.code = 200;
+            throw ex;
+        }
+
+        // *** finish ***
+        // replaceReference will throw an error if nothing was updated which will end execution here
+        // no error means we have a new item to deploy and need to update the item in our retrieve folder
+        return item;
+    }
 }
 
 // Assign definition to static attributes