mcdev 6.0.2 → 7.0.0

package/lib/metadataTypes/ImportFile.js

@@ -1,11 +1,23 @@
 'use strict';
 
-import TYPE from '../../types/mcdev.d.js';
 import MetadataType from './MetadataType.js';
 import { Util } from '../util/util.js';
 import File from '../util/file.js';
 import cache from '../util/cache.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
+ */
+
 /**
  * ImportFile MetadataType
  *
@@ -17,23 +29,71 @@ class ImportFile extends MetadataType {
      * Endpoint /automation/v1/imports/ return all Import Files with all details.
      * Currently it is not needed to loop over Imports with endpoint /automation/v1/imports/{id}
      *
-     * @param {string} retrieveDir Directory where retrieved metadata directory will be saved
-     * @param {void} [_] unused parameter
-     * @param {void} [__] unused parameter
+     * @param {string} [retrieveDir] Directory where retrieved metadata directory will be saved
+     * @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
+     * @returns {Promise.<MetadataTypeMapObj>} Promise
      */
-    static retrieve(retrieveDir, _, __, key) {
-        return super.retrieveREST(retrieveDir, '/automation/v1/imports/', null, key);
+    static async retrieve(retrieveDir, _, __, key) {
+        let objectId = null;
+        if (key) {
+            // using '?$filter=customerKey%20eq%20' + encodeURIComponent(key) would also work but that just retrieves more data for no reason
+            objectId = await this._getObjectIdForSingleRetrieve(key);
+            if (!objectId) {
+                // avoid running the rest request below by returning early
+                Util.logger.info(
+                    `Downloaded: ${this.definition.type} (0)${Util.getKeysString(key)}`
+                );
+                return { metadata: {}, type: this.definition.type };
+            }
+        }
+        Util.logger.debug(' - retrieving extended metadata for SMS imports');
+        const smsImportResults = await this.client.rest.getBulk(
+            '/legacy/v1/beta/mobile/imports/',
+            50
+        );
+        this.smsImports = {};
+        if (smsImportResults.totalResults > 0 && smsImportResults.entry.length > 0) {
+            Util.logger.info(`Caching dependent Metadata: dataExtension (source for SMS imports)`);
+            const sourceObject = {};
+            for (const item of smsImportResults.entry) {
+                // this api does not show the key but the name is assumed to be unique
+                this.smsImports[item.name] = item;
+
+                try {
+                    if (!sourceObject[item.sourceObjectId]) {
+                        sourceObject[item.sourceObjectId] = await this.client.rest.get(
+                            '/legacy/v1/beta/object/' + item.sourceObjectId
+                        );
+                    }
+                    item.sourceObjectKey = sourceObject[item.sourceObjectId].key;
+                } catch {
+                    Util.logger.warn(
+                        `endpoint /legacy/v1/beta/object/${item.sourceObjectId} does not exist`
+                    );
+                }
+            }
+        }
+
+        return super.retrieveREST(
+            retrieveDir,
+            '/automation/v1/imports/' + (objectId || ''),
+            null,
+            key
+        );
     }
 
     /**
      * Retrieves import definition metadata for caching
      *
-     * @returns {Promise.<TYPE.MetadataTypeMapObj>} Promise
+     * @param {void | string[]} [_] parameter not used
+     * @param {void | string[]} [__] parameter not used
+     * @param {string} [key] customer key of single item to retrieve
+     * @returns {Promise.<MetadataTypeMapObj>} Promise
      */
-    static async retrieveForCache() {
-        return super.retrieveREST(null, '/automation/v1/imports/');
+    static retrieveForCache(_, __, key) {
+        return this.retrieve(null, null, null, key);
     }
 
     /**
@@ -41,16 +101,16 @@ class ImportFile extends MetadataType {
      *
      * @param {string} templateDir Directory where retrieved metadata directory will be saved
      * @param {string} name name of the metadata file
-     * @param {TYPE.TemplateMap} templateVariables variables to be replaced in the metadata
-     * @returns {Promise.<TYPE.MetadataTypeItemObj>} Promise
+     * @param {TemplateMap} templateVariables variables to be replaced in the metadata
+     * @returns {Promise.<MetadataTypeItemObj>} Promise
      */
     static async retrieveAsTemplate(templateDir, name, templateVariables) {
-        const res = await this.client.rest.get(
-            '/automation/v1/imports/?$filter=name%20eq%20' + encodeURIComponent(name)
-        );
-        if (Array.isArray(res?.items) && res?.items.length) {
+        // using '?$filter=name%20eq%20' + encodeURIComponent(name) would also work but that just retrieves more data for no reason
+        const cache = await this.retrieveForCache(null, null, 'name:' + name);
+        const metadataArr = Object.values(cache?.metadata);
+        if (Array.isArray(metadataArr) && metadataArr.length) {
             // eq-operator returns a similar, not exact match and hence might return more than 1 entry
-            const metadata = res.items.find((item) => item.name === name);
+            const metadata = metadataArr.find((item) => item.name === name);
             if (!metadata) {
                 Util.logger.error(`No ${this.definition.typeName} found with name "${name}"`);
                 return;
@@ -58,7 +118,7 @@ class ImportFile extends MetadataType {
             const originalKey = metadata[this.definition.keyField];
             const val = JSON.parse(
                 Util.replaceByObject(
-                    JSON.stringify(this.parseMetadata(metadata)),
+                    JSON.stringify(this.postRetrieveTasks(metadata)),
                     templateVariables
                 )
             );
@@ -72,32 +132,44 @@ class ImportFile extends MetadataType {
             );
             Util.logger.info(`- templated ${this.definition.type}: ${name}`);
             return { metadata: val, type: this.definition.type };
-        } else if (res?.items) {
+        } else if (metadataArr) {
             Util.logger.error(`No ${this.definition.typeName} found with name "${name}"`);
         } else {
             throw new Error(
                 `Encountered unknown error when retrieveing ${
                     this.definition.typeName
-                } "${name}": ${JSON.stringify(res)}`
+                } "${name}": ${JSON.stringify(metadataArr)}`
             );
         }
     }
-
     /**
-     * manages post retrieve steps
+     * helper to allow us to select single metadata entries via REST
      *
-     * @param {TYPE.MetadataTypeItem} importDef a single importDef
-     * @returns {TYPE.MetadataTypeItem} metadata
+     * @private
+     * @param {string} key customer key
+     * @returns {Promise.<string>} objectId or enpty string
      */
-    static postRetrieveTasks(importDef) {
-        const val = this.parseMetadata(importDef);
-        return val;
+    static async _getObjectIdForSingleRetrieve(key) {
+        const response = await this.client.soap.retrieve('ImportDefinition', ['ObjectID'], {
+            filter: key.startsWith('name:')
+                ? {
+                      leftOperand: 'Name',
+                      operator: 'equals',
+                      rightOperand: key.slice(5),
+                  }
+                : {
+                      leftOperand: 'CustomerKey',
+                      operator: 'equals',
+                      rightOperand: key,
+                  },
+        });
+        return response?.Results?.length ? response.Results[0].ObjectID : null;
     }
 
     /**
      * Creates a single Import File
      *
-     * @param {TYPE.MetadataTypeItem} importFile a single Import File
+     * @param {MetadataTypeItem} importFile a single Import File
      * @returns {Promise} Promise
      */
     static create(importFile) {
@@ -107,7 +179,7 @@ class ImportFile extends MetadataType {
     /**
      * Updates a single Import File
      *
-     * @param {TYPE.MetadataTypeItem} importFile a single Import File
+     * @param {MetadataTypeItem} importFile a single Import File
      * @returns {Promise} Promise
      */
     static update(importFile) {
@@ -116,70 +188,172 @@ class ImportFile extends MetadataType {
             '/automation/v1/imports/' + importFile.importDefinitionId
         );
     }
+    /**
+     * Deploys metadata
+     *
+     * @param {MetadataTypeMap} metadataMap metadata mapped by their keyField
+     * @param {string} deployDir directory where deploy metadata are saved
+     * @param {string} retrieveDir directory where metadata after deploy should be saved
+     * @returns {Promise.<MetadataTypeMap>} Promise of keyField => metadata map
+     */
+    static async deploy(metadataMap, deployDir, retrieveDir) {
+        if (
+            Object.values(metadataMap).filter(
+                (item) => item.destination.c__destinationType === 'SMS'
+            ).length > 0
+        ) {
+            Util.logger.info(`Caching dependent Metadata: dataExtension (source for SMS imports)`);
+
+            const dataExtensionLegacyResult = await this.client.rest.getBulk(
+                '/legacy/v1/beta/object/',
+                500
+            );
+            this.dataExtensionsLegacy = {};
+            if (dataExtensionLegacyResult?.entry?.length) {
+                for (const item of dataExtensionLegacyResult.entry) {
+                    this.dataExtensionsLegacy[item.key] = item;
+                }
+            }
+        }
+
+        return super.deploy(metadataMap, deployDir, retrieveDir);
+    }
 
     /**
      * prepares a import definition for deployment
      *
-     * @param {TYPE.MetadataTypeItem} metadata a single importDef
-     * @returns {Promise} Promise
+     * @param {MetadataTypeItem} metadata a single importDef
+     * @returns {Promise.<MetadataTypeItem>} Promise
      */
     static async preDeployTasks(metadata) {
-        metadata.fileTransferLocationId = cache.searchForField(
-            'fileLocation',
-            metadata.r__fileLocation_name,
-            'name',
-            'id'
-        );
-        delete metadata.r__fileLocation_name;
-
-        if (metadata.c__destinationType === 'DataExtension') {
-            if (metadata.r__dataExtension_CustomerKey) {
-                metadata.destinationObjectId = cache.searchForField(
-                    'dataExtension',
-                    metadata.r__dataExtension_CustomerKey,
-                    'CustomerKey',
-                    'ObjectID'
+        const fileLocation = cache.getByKey('fileLocation', metadata.source.r__fileLocation_name);
+        if (!fileLocation) {
+            throw new Error(`fileLocation ${metadata.r__fileLocation_name} not found in cache`);
+        }
+
+        metadata.fileTransferLocationId = fileLocation.id;
+        metadata.fileTransferLocationTypeId = fileLocation.locationTypeId;
+        delete metadata.source.r__fileLocation_name;
+
+        switch (metadata.destination.c__destinationType) {
+            case 'DataExtension': {
+                if (metadata.destination.r__dataExtension_key) {
+                    metadata.destinationObjectId = cache.searchForField(
+                        'dataExtension',
+                        metadata.destination.r__dataExtension_key,
+                        'CustomerKey',
+                        'ObjectID'
+                    );
+                    delete metadata.destination.r__dataExtension_key;
+                } else {
+                    throw new Error('Import Destination DataExtension not defined');
+                }
+                break;
+            }
+            case 'List': {
+                if (metadata.destination.r__list_PathName) {
+                    metadata.destinationObjectId = cache.getListObjectId(
+                        metadata.destination.r__list_PathName,
+                        'ObjectID'
+                    );
+                    // destinationId is also needed for List types
+                    metadata.destinationId = cache.getListObjectId(
+                        metadata.destination.r__list_PathName,
+                        'ID'
+                    );
+                    delete metadata.destination.r__list_PathName;
+                } else {
+                    throw new Error('Import Destination List not defined');
+                }
+                break;
+            }
+            case 'SMS': {
+                if (metadata.destination.r__mobileKeyword_key) {
+                    // code
+                    const codeObj = cache.getByKey(
+                        'mobileCode',
+                        metadata.destination.r__mobileKeyword_key.split('.')[0]
+                    );
+                    if (!codeObj) {
+                        throw new Error(
+                            `mobileCode ${metadata.destination.r__mobileKeyword_key} not found in cache`
+                        );
+                    }
+                    metadata.code = codeObj;
+
+                    // keyword
+                    const keywordObj = cache.getByKey(
+                        'mobileKeyword',
+                        metadata.destination.r__mobileKeyword_key
+                    );
+                    if (!keywordObj) {
+                        throw new Error(
+                            `mobileKeyword ${metadata.destination.r__mobileKeyword_key} not found in cache`
+                        );
+                    }
+                    metadata.keyword = keywordObj;
+                } else {
+                    Util.logger.error(
+                        ` - importFile ${metadata[this.definition.keyField]}: No code or keyword info found. Please re-download this from the source.`
+                    );
+                }
+
+                // destination
+                metadata.destinationObjectId = '00000000-0000-0000-0000-000000000000';
+                metadata.destinationObjectType = 'MobileSubscription';
+                // source
+                if (this.dataExtensionsLegacy[metadata.source.r__dataExtension_key]) {
+                    metadata.sourceObjectId =
+                        this.dataExtensionsLegacy[metadata.source.r__dataExtension_key].id;
+                    metadata.sourceObjectName =
+                        this.dataExtensionsLegacy[
+                            metadata.source.r__dataExtension_key
+                        ].dataExtensionName;
+                    delete metadata.source.r__dataExtension_key;
+                }
+
+                Util.logger.debug(
+                    ` - importFile ${metadata[this.definition.keyField]}: Import Destination Type ${
+                        metadata.destination.c__destinationType
+                    } not fully supported. Deploy might fail.`
                 );
-                delete metadata.r__dataExtension_CustomerKey;
-            } else {
-                throw new Error('Import Destination DataExtension not defined');
+                break;
             }
-        } else if (metadata.c__destinationType === 'List') {
-            if (metadata.r__list_PathName) {
-                metadata.destinationObjectId = cache.getListObjectId(
-                    metadata.r__list_PathName,
-                    'ObjectID'
+            default: {
+                Util.logger.debug(
+                    ` - importFile ${metadata[this.definition.keyField]}: Import Destination Type ${
+                        metadata.destination.c__destinationType
+                    } not fully supported. Deploy might fail.`
                 );
-                // destinationId is also needed for List types
-                metadata.destinationId = cache.getListObjectId(metadata.r__list_PathName, 'ID');
-                delete metadata.r__list_PathName;
-            } else {
-                throw new Error('Import Destination List not defined');
             }
-        } else {
-            Util.logger.debug(
-                ` - importFile ${metadata[this.definition.keyField]}: Import Destination Type ${
-                    metadata.c__destinationType
-                } not fully supported. Deploy might fail.`
-            );
+        }
+        if (metadata.c__blankFileProcessing) {
+            // omit this if not set
+            metadata.blankFileProcessingType =
+                this.definition.blankFileProcessingTypeMapping[metadata.c__blankFileProcessing];
         }
         // When the destinationObjectTypeId is 584 it refers to Mobile Connect which is not supported as an Import Type
         metadata.destinationObjectTypeId =
-            this.definition.destinationObjectTypeMapping[metadata.c__destinationType];
+            this.definition.destinationObjectTypeMapping[metadata.destination.c__destinationType];
         metadata.subscriberImportTypeId =
             this.definition.subscriberImportTypeMapping[metadata.c__subscriberImportType];
         metadata.updateTypeId = this.definition.updateTypeMapping[metadata.c__dataAction];
+
+        delete metadata.destination;
+        delete metadata.source;
         return metadata;
     }
 
     /**
-     * parses retrieved Metadata before saving
+     * manages post retrieve steps
      *
-     * @param {TYPE.MetadataTypeItem} metadata a single import definition
-     * @returns {TYPE.MetadataTypeItem} parsed metadata definition
+     * @param {MetadataTypeItem} metadata a single item
+     * @returns {MetadataTypeItem} parsed metadata
      */
-    static parseMetadata(metadata) {
-        metadata.r__fileLocation_name = cache.searchForField(
+    static postRetrieveTasks(metadata) {
+        metadata.destination = {};
+        metadata.source = {};
+        metadata.source.r__fileLocation_name = cache.searchForField(
             'fileLocation',
             metadata.fileTransferLocationId,
             'id',
@@ -188,34 +362,94 @@ class ImportFile extends MetadataType {
         delete metadata.fileTransferLocationId;
 
         // * When the destinationObjectTypeId is 584 it refers to Mobile Connect which is not supported as an Import Type
-        metadata.c__destinationType = Util.inverseGet(
+        metadata.destination.c__destinationType = Util.inverseGet(
             this.definition.destinationObjectTypeMapping,
             metadata.destinationObjectTypeId
         );
-        delete metadata.destinationObjectTypeId;
-        if (metadata.c__destinationType === 'DataExtension') {
-            try {
-                metadata.r__dataExtension_CustomerKey = cache.searchForField(
-                    'dataExtension',
-                    metadata.destinationObjectId,
-                    'ObjectID',
-                    'CustomerKey'
-                );
+        switch (metadata.destination.c__destinationType) {
+            case 'DataExtension': {
+                try {
+                    metadata.destination.r__dataExtension_key = cache.searchForField(
+                        'dataExtension',
+                        metadata.destinationObjectId,
+                        'ObjectID',
+                        'CustomerKey'
+                    );
+                    delete metadata.destinationObjectId;
+                } catch (ex) {
+                    Util.logger.warn(` - ImportFile ${metadata.customerKey}: ${ex.message}`);
+                }
+
+                break;
+            }
+            case 'List': {
+                try {
+                    metadata.destination.r__list_PathName = cache.getListPathName(
+                        metadata.destinationObjectId,
+                        'ObjectID'
+                    );
+                    delete metadata.destinationObjectId;
+                } catch (ex) {
+                    Util.logger.warn(` - ImportFile ${metadata.customerKey}: ${ex.message}`);
+                }
+
+                break;
+            }
+            case 'SMS': {
+                if (this.smsImports[metadata.name]) {
+                    const smsImport = this.smsImports[metadata.name];
+
+                    // code
+                    try {
+                        cache.searchForField('mobileCode', smsImport.code?.code, 'code', 'code');
+                    } catch (ex) {
+                        Util.logger.warn(` - ImportFile ${metadata.customerKey}: ${ex.message}`);
+                    }
+                    // keyword
+                    try {
+                        cache.searchForField(
+                            'mobileKeyword',
+                            smsImport.keyword?.keyword,
+                            'c__codeKeyword',
+                            'c__codeKeyword'
+                        );
+                    } catch (ex) {
+                        Util.logger.warn(` - ImportFile ${metadata.customerKey}: ${ex.message}`);
+                    }
+
+                    // code + keyword
+                    metadata.destination.r__mobileKeyword_key =
+                        smsImport.code?.code + '.' + smsImport.keyword?.keyword;
+                    // source dataExtension
+                    if (smsImport.sourceObjectKey) {
+                        metadata.source.r__dataExtension_key = smsImport.sourceObjectKey;
+                    }
+                } else {
+                    Util.logger.warn(
+                        ` - ImportFile ${metadata.customerKey}: Could not find mobile code and keyword nor source for this SMS import activity.`
+                    );
+                }
+                // remove empty desitination
                 delete metadata.destinationObjectId;
-            } catch (ex) {
-                Util.logger.warn(` - ImportFile ${metadata.customerKey}: ${ex.message}`);
+
+                break;
             }
-        } else if (metadata.c__destinationType === 'List') {
-            try {
-                metadata.r__list_PathName = cache.getListPathName(
-                    metadata.destinationObjectId,
-                    'ObjectID'
+            default: {
+                Util.logger.debug(
+                    ` - ImportFile ${metadata.customerKey}: Destination Type ${metadata.destinationObjectTypeId} not fully supported. Deploy might fail.`
                 );
-                delete metadata.destinationObjectId;
-            } catch (ex) {
-                Util.logger.warn(` - ImportFile ${metadata.customerKey}: ${ex.message}`);
             }
         }
+        delete metadata.destinationObjectTypeId;
+
+        if (metadata.blankFileProcessingType) {
+            // omit this if not set
+            metadata.c__blankFileProcessing = Util.inverseGet(
+                this.definition.blankFileProcessingTypeMapping,
+                metadata.blankFileProcessingType
+            );
+            delete metadata.blankFileProcessingType;
+        }
 
         metadata.c__subscriberImportType = Util.inverseGet(
             this.definition.subscriberImportTypeMapping,
@@ -229,6 +463,22 @@ class ImportFile extends MetadataType {
         delete metadata.updateTypeId;
         return metadata;
     }
+
+    /**
+     * Delete a metadata item from the specified business unit
+     *
+     * @param {string} customerKey Identifier of data extension
+     * @returns {Promise.<boolean>} deletion success flag
+     */
+    static async deleteByKey(customerKey) {
+        // delete only works with the query's object id
+        const objectId = customerKey ? await this._getObjectIdForSingleRetrieve(customerKey) : null;
+        if (!objectId) {
+            Util.logger.error(` - import not found`);
+            return false;
+        }
+        return super.deleteByKeyREST('/automation/v1/imports/' + objectId, customerKey);
+    }
 }
 
 // Assign definition to static attributes