Feature/62 resolve sendClassification & senderProfile in triggeredSend, emailSend and journey

lib/index.js

@@ -571,7 +571,7 @@ class Mcdev {
                 return;
             }
             Util.logger.info(
-                Util.getGrayMsg(` - Deleting ${type} with key ${customerKey} on BU ${businessUnit}`)
+                Util.getGrayMsg(` - Deleting ${type} ${customerKey} on BU ${businessUnit}`)
             );
             try {
                 MetadataTypeInfo[type].properties = properties;

lib/metadataTypes/Asset.js

@@ -60,7 +60,7 @@ class Asset extends MetadataType {
         for (const subType of subTypeArr) {
             // each subtype contains multiple different specific types (images contains jpg and png for example)
             // we use await here to limit the risk of too many concurrent api requests at time
-            items.push(...(await this.requestSubType(subType, retrieveDir, null, null, key)));
+            items.push(...(await this.requestSubType(subType, retrieveDir, key, null)));
         }
         const metadata = this.parseResponseBody({ items: items });
         if (retrieveDir) {
@@ -139,7 +139,12 @@ class Asset extends MetadataType {
             // each subtype contains multiple different specific types (images contains jpg and png for example)
             // we use await here to limit the risk of too many concurrent api requests at time
             items.push(
-                ...(await this.requestSubType(subType, templateDir, name, templateVariables))
+                ...(await this.requestSubType(
+                    subType,
+                    templateDir,
+                    'name:' + name,
+                    templateVariables
+                ))
             );
         }
         const metadata = this.parseResponseBody({ items: items });
@@ -200,12 +205,11 @@ class Asset extends MetadataType {
      *
      * @param {string} subType group of similar assets to put in a folder (ie. images)
      * @param {string} [retrieveDir] target directory for saving assets
-     * @param {string} [templateName] name of the metadata file
+     * @param {string} [key] key/id/name to filter by
      * @param {TemplateMap} [templateVariables] variables to be replaced in the metadata
-     * @param {string} [key] customer key to filter by
      * @returns {Promise.<object[]>} Promise
      */
-    static async requestSubType(subType, retrieveDir, templateName, templateVariables, key) {
+    static async requestSubType(subType, retrieveDir, key, templateVariables) {
         if (retrieveDir) {
             Util.logger.info(`- Retrieving Subtype: ${subType}`);
         } else {
@@ -227,34 +231,34 @@ class Asset extends MetadataType {
             fields: ['category', 'createdDate', 'createdBy', 'modifiedDate', 'modifiedBy'], // get folder to allow duplicate name check against cache
         };
 
-        if (templateName) {
+        if (key) {
             payload.query = {
                 leftOperand: {
                     property: 'assetType.id',
                     simpleOperator: 'in',
                     value: subtypeIds,
                 },
                 logicalOperator: 'AND',
-                rightOperand: {
+            };
+            if (key.startsWith('id:')) {
+                payload.query.rightOperand = {
+                    property: this.definition.idField,
+                    simpleOperator: 'equal',
+                    value: key.slice(3),
+                };
+            } else if (key.startsWith('name:')) {
+                payload.query.rightOperand = {
                     property: this.definition.nameField,
                     simpleOperator: 'equal',
-                    value: templateName,
-                },
-            };
-        } else if (key) {
-            payload.query = {
-                leftOperand: {
-                    property: 'assetType.id',
-                    simpleOperator: 'in',
-                    value: subtypeIds,
-                },
-                logicalOperator: 'AND',
-                rightOperand: {
+                    value: key.slice(5),
+                };
+            } else {
+                payload.query.rightOperand = {
                     property: this.definition.keyField,
                     simpleOperator: 'equal',
                     value: key,
-                },
-            };
+                };
+            }
         } else {
             payload.query = {
                 property: 'assetType.id',
@@ -1774,9 +1778,9 @@ class Asset extends MetadataType {
      *
      * @private
      * @param {string} key customer key
-     * @returns {Promise.<string>} objectId or enpty string
+     * @returns {Promise.<string>} id value or null
      */
-    static async _getObjectIdForSingleRetrieve(key) {
+    static async _getIdForSingleRetrieve(key) {
         const name = key.startsWith('name:') ? key.slice(5) : null;
         const filter = name
             ? '?$filter=name%20eq%20' + encodeURIComponent(name)
@@ -1789,40 +1793,61 @@ class Asset extends MetadataType {
         );
         return found?.id || null;
     }
+    /**
+     * helper to allow us to select single metadata entries via REST
+     *
+     * @private
+     * @param {string} id id field
+     * @returns {Promise.<string>} key value or null
+     */
+    static async _getKeyForSingleRetrieve(id) {
+        const results = await this.client.rest.get('/asset/v1/content/assets/' + id);
+        return results?.customerKey || null;
+    }
 
     /**
      * Delete a metadata item from the specified business unit
      *
-     * @param {string} customerKey Identifier of data extension
+     * @param {string} key Identifier of item
      * @returns {Promise.<boolean>} deletion success flag
      */
-    static async deleteByKey(customerKey) {
+    static async deleteByKey(key) {
         // delete only works with the query's object id
-        const objectId = customerKey ? await this._getObjectIdForSingleRetrieve(customerKey) : null;
-        if (!objectId) {
+        let id;
+        if (key?.startsWith('id:')) {
+            id = key.slice(3);
+            // we need to get the actual key so that postDeletetTasks know what to do
+            key = await this._getKeyForSingleRetrieve(id);
+        } else {
+            id = key ? await this._getIdForSingleRetrieve(key) : null;
+        }
+        if (!id) {
             Util.logger.error(` - ${this.definition.type} not found`);
             return false;
         }
-        return super.deleteByKeyREST('/asset/v1/content/assets/' + objectId, customerKey);
+        return super.deleteByKeyREST('/asset/v1/content/assets/' + id, key);
     }
 
     /**
      * clean up after deleting a metadata item
      * cannot use the generic method due to the complexity of how assets are saved to disk
      *
-     * @param {string} customerKey Identifier of metadata item
+     * @param {string} key Identifier of metadata item
      * @returns {Promise.<void>} -
      */
-    static async postDeleteTasks(customerKey) {
-        const fileArr = await this.getFilesToCommit([customerKey]);
+    static async postDeleteTasks(key) {
+        if (key?.startsWith('id:')) {
+            // sad
+        }
+        const fileArr = await this.getFilesToCommit([key]);
 
         // check if asset sits in its own folder
         const ownFolderIndex =
-            fileArr[0].indexOf(customerKey + '\\') > 0
-                ? fileArr[0].indexOf(customerKey + '\\')
-                : fileArr[0].indexOf(customerKey + '/');
+            fileArr[0].indexOf(key + '\\') > 0
+                ? fileArr[0].indexOf(key + '\\')
+                : fileArr[0].indexOf(key + '/');
         if (ownFolderIndex > 0) {
-            fileArr.push(fileArr[0].slice(0, ownFolderIndex + customerKey.length));
+            fileArr.push(fileArr[0].slice(0, ownFolderIndex + key.length));
         }
 
         for (const filePath of fileArr) {

lib/metadataTypes/Automation.js

@@ -61,7 +61,10 @@ class Automation extends MetadataType {
         } else {
             /** @type {SoapRequestParams} */
             let requestParams = null;
-            if (key) {
+            const objectIds = [];
+            if (key?.startsWith('id:')) {
+                objectIds.push(key.slice(3));
+            } else if (key) {
                 requestParams = {
                     filter: {
                         leftOperand: 'CustomerKey',
@@ -75,12 +78,16 @@ class Automation extends MetadataType {
                 ['ObjectID'],
                 requestParams
             );
+            if (results?.Results?.length) {
+                objectIds.push(...results.Results.map((item) => item.ObjectID));
+            }
+
             // the API seems to handle 50 concurrent requests nicely
-            const response = results?.Results?.length
+            const response = objectIds.length
                 ? await this.retrieveRESTcollection(
-                      results?.Results.map((item) => ({
-                          id: item.ObjectID,
-                          uri: '/automation/v1/automations/' + item.ObjectID,
+                      objectIds.map((objectID) => ({
+                          id: objectID,
+                          uri: '/automation/v1/automations/' + objectID,
                       })),
                       50,
                       !key

lib/metadataTypes/EmailSend.js

@@ -183,7 +183,7 @@ class EmailSend extends MetadataType {
             if (sdl.r__dataExtension_Key) {
                 if (sdl.DataSourceTypeID !== 'CustomObject') {
                     throw new Error(
-                        ` ☇ skipping ${this.definition.type} ${metadata.Name} (${metadata.CustomerKey}): Expecting DataSourceTypeID to equal 'CustomObject' when r__dataExtension_Key is defined; Found '${sdl.DataSourceTypeID}'`
+                        `Expecting DataSourceTypeID to equal 'CustomObject' when r__dataExtension_Key is defined; Found '${sdl.DataSourceTypeID}'`
                     );
                 }
                 sdl.CustomObjectID = cache.searchForField(
@@ -195,7 +195,7 @@ class EmailSend extends MetadataType {
                 delete sdl.r__dataExtension_Key;
             } else if (sdl.DataSourceTypeID === 'CustomObject') {
                 throw new Error(
-                    ` ☇ skipping ${this.definition.type} ${metadata.Name} (${metadata.CustomerKey}): Expecting r__dataExtension_Key to be defined if DataSourceTypeID='CustomObject'`
+                    `Expecting r__dataExtension_Key to be defined if DataSourceTypeID='CustomObject'`
                 );
             }
             if (!sdl.SalesForceObjectID || sdl.SalesForceObjectID === '') {
@@ -208,13 +208,49 @@ class EmailSend extends MetadataType {
                     ID: cache.getListObjectId(sdl.r__list_PathName, 'ID'),
                 };
                 delete sdl.r__list_PathName;
-            } else {
+            } else if (sdl.SendDefinitionListType === 'SourceList') {
+                // dont throw an error for type 'ExclusionList'
                 throw new Error(
-                    ` ☇ skipping ${this.definition.type} ${metadata.Name} (${metadata.CustomerKey}) Field SendDefinitionList.r__list_PathName was not defined. Please try re-retrieving this ESD from your source BU.`
+                    `Field SendDefinitionList.r__list_PathName was not defined. Please try re-retrieving this ESD from your source BU.`
                 );
             }
         }
 
+        // sender profile
+        if (metadata.r__senderProfile_CustomerKey) {
+            cache.searchForField(
+                'senderProfile',
+                metadata.r__senderProfile_CustomerKey,
+                'CustomerKey',
+                'CustomerKey'
+            );
+            metadata.SenderProfile = {
+                CustomerKey: metadata.r__senderProfile_CustomerKey,
+            };
+            delete metadata.r__senderProfile_CustomerKey;
+        }
+        // send classification
+        if (metadata.r__sendClassification_CustomerKey) {
+            cache.searchForField(
+                'sendClassification',
+                metadata.r__sendClassification_CustomerKey,
+                'CustomerKey',
+                'CustomerKey'
+            );
+            metadata.SendClassification = {
+                CustomerKey: metadata.r__sendClassification_CustomerKey,
+            };
+            delete metadata.r__sendClassification_CustomerKey;
+        }
+        // delivery profile
+        if (metadata.r__deliveryProfile_key) {
+            cache.searchForField('deliveryProfile', metadata.r__deliveryProfile_key, 'key', 'key');
+            metadata.DeliveryProfile = {
+                CustomerKey: metadata.r__deliveryProfile_key,
+            };
+            delete metadata.r__deliveryProfile_key;
+        }
+
         return metadata;
     }
 
@@ -319,6 +355,59 @@ class EmailSend extends MetadataType {
             }
         }
 
+        // sender profile
+        if (metadata.SenderProfile?.CustomerKey) {
+            try {
+                cache.searchForField(
+                    'senderProfile',
+                    metadata.SenderProfile.CustomerKey,
+                    'CustomerKey',
+                    'CustomerKey'
+                );
+                metadata.r__senderProfile_CustomerKey = 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_CustomerKey =
+                    metadata.SendClassification.CustomerKey;
+                delete metadata.SendClassification;
+            } catch (ex) {
+                Util.logger.warn(
+                    ` - ${this.definition.type} ${metadata.CustomerKey}: ${ex.message}`
+                );
+            }
+        }
+        // delivery profile
+        if (metadata.DeliveryProfile?.CustomerKey) {
+            try {
+                cache.searchForField(
+                    'deliveryProfile',
+                    metadata.DeliveryProfile.CustomerKey,
+                    'key',
+                    'key'
+                );
+                metadata.r__deliveryProfile_key = metadata.DeliveryProfile.CustomerKey;
+                delete metadata.DeliveryProfile;
+            } catch (ex) {
+                Util.logger.warn(
+                    ` - ${this.definition.type} ${metadata.CustomerKey}: ${ex.message}`
+                );
+            }
+        }
+
         return metadata;
     }
 }