Feature/9 add filterDefinition & resolve filter details

lib/MetadataTypeDefinitions.js

@@ -22,6 +22,8 @@ const MetadataTypeDefinitions = {
     fileLocation: require('./metadataTypes/definitions/FileLocation.definition'),
     fileTransfer: require('./metadataTypes/definitions/FileTransfer.definition'),
     filter: require('./metadataTypes/definitions/Filter.definition'),
+    filterDefinition: require('./metadataTypes/definitions/FilterDefinition.definition'),
+    filterDefinitionHidden: require('./metadataTypes/definitions/FilterDefinitionHidden.definition'),
     folder: require('./metadataTypes/definitions/Folder.definition'),
     importFile: require('./metadataTypes/definitions/ImportFile.definition'),
     journey: require('./metadataTypes/definitions/Journey.definition'),

lib/MetadataTypeInfo.js

@@ -22,6 +22,8 @@ const MetadataTypeInfo = {
     fileLocation: require('./metadataTypes/FileLocation'),
     fileTransfer: require('./metadataTypes/FileTransfer'),
     filter: require('./metadataTypes/Filter'),
+    filterDefinition: require('./metadataTypes/FilterDefinition'),
+    filterDefinitionHidden: require('./metadataTypes/FilterDefinitionHidden'),
     folder: require('./metadataTypes/Folder'),
     importFile: require('./metadataTypes/ImportFile'),
     journey: require('./metadataTypes/Journey'),

lib/metadataTypes/DataExtension.js

@@ -1341,7 +1341,7 @@ class DataExtension extends MetadataType {
      * @returns {Promise.<{metadata: TYPE.DataExtensionMap, type: string}>} Promise
      */
     static async retrieveForCache() {
-        return this.retrieve(null, ['ObjectID', 'CustomerKey', 'Name'], this.buObject, null, null);
+        return this.retrieve(null, ['ObjectID', 'CustomerKey', 'Name']);
     }
     /**
      * Retrieves dataExtension metadata in template format.

lib/metadataTypes/Filter.js

@@ -2,6 +2,15 @@
 
 const TYPE = require('../../types/mcdev.d');
 const MetadataType = require('./MetadataType');
+const Util = require('../util/util');
+const cache = require('../util/cache');
+
+const dataTypes = {
+    1: 'List',
+    2: 'DataExtension',
+    3: 'Group Wizard',
+    4: 'Behavioral Data',
+};
 
 /**
  * Filter MetadataType
@@ -19,11 +28,179 @@ class Filter extends MetadataType {
      * @param {void} [_] unused parameter
      * @param {void} [__] unused parameter
      * @param {string} [key] customer key of single item to retrieve
-     * @returns {Promise.<TYPE.MetadataTypeMapObj>} Promise
+     * @returns {Promise.<{metadata: TYPE.FilterMap, type: string}>} Promise of items
      */
     static async retrieve(retrieveDir, _, __, key) {
         return super.retrieveREST(retrieveDir, '/automation/v1/filters/', null, key);
     }
+    /**
+     * parses retrieved Metadata before saving
+     *
+     * @param {TYPE.FilterItem} metadata a single record
+     * @returns {TYPE.FilterItem} parsed metadata definition
+     */
+    static postRetrieveTasks(metadata) {
+        // folder
+        this.setFolderPath(metadata);
+
+        try {
+            // filterDefinition
+            metadata.r__filterDefinition_CustomerKey = cache.searchForField(
+                'filterDefinition',
+                metadata.filterDefinitionId,
+                'id',
+                'key'
+            );
+            delete metadata.filterDefinitionId;
+        } catch {
+            try {
+                // filterDefinition
+                metadata.r__filterDefinition_CustomerKey = cache.searchForField(
+                    'filterDefinitionHidden',
+                    metadata.filterDefinitionId,
+                    'id',
+                    'key'
+                );
+                delete metadata.filterDefinitionId;
+            } catch {
+                // ignore
+            }
+        }
+        try {
+            // source
+            if (metadata.sourceTypeId === 1) {
+                // list
+            } else if (metadata.sourceTypeId === 2) {
+                // dataExtension
+                metadata.r__source_dataExtension_CustomerKey = cache.searchForField(
+                    'dataExtension',
+                    metadata.sourceObjectId,
+                    'ObjectID',
+                    'CustomerKey'
+                );
+                delete metadata.sourceObjectId;
+                delete metadata.sourceTypeId;
+            } else {
+                Util.logger.warn(
+                    ` - Filter '${metadata.name}' (${
+                        metadata.customerKey
+                    }): Unsupported source type ${metadata.sourceTypeId}=${
+                        dataTypes[metadata.sourceTypeId]
+                    }`
+                );
+            }
+        } catch (ex) {
+            Util.logger.warn(
+                ` - filter '${metadata.name}' (${metadata.customerKey}): Destination not found (${ex.message})`
+            );
+        }
+        try {
+            // target
+            if (metadata.destinationTypeId === 1) {
+                // list
+            } else if (metadata.destinationTypeId === 2) {
+                // dataExtension
+                metadata.r__destination_dataExtension_CustomerKey = cache.searchForField(
+                    'dataExtension',
+                    metadata.destinationObjectId,
+                    'ObjectID',
+                    'CustomerKey'
+                );
+                delete metadata.destinationObjectId;
+                delete metadata.destinationTypeId;
+            } else {
+                Util.logger.warn(
+                    ` - filter '${metadata.name}' (${
+                        metadata.customerKey
+                    }): Unsupported destination type ${metadata.destinationTypeId}=${
+                        dataTypes[metadata.destinationTypeId]
+                    }`
+                );
+            }
+        } catch (ex) {
+            Util.logger.warn(
+                ` - filter '${metadata.name}' (${metadata.customerKey}): Source not found (${ex.message})`
+            );
+        }
+        return metadata;
+    }
+    /**
+     * prepares a record for deployment
+     *
+     * @param {TYPE.FilterItem} metadata a single record
+     * @returns {Promise.<TYPE.FilterItem>} Promise of updated single record
+     */
+    static async preDeployTasks(metadata) {
+        // folder
+        if (metadata.r__folder_Path) {
+            metadata.categoryId = cache.searchForField(
+                'folder',
+                metadata.r__folder_Path,
+                'Path',
+                'ID'
+            );
+            delete metadata.r__folder_Path;
+        }
+
+        // filterDefinition
+        if (metadata.r__filterDefinition_CustomerKey) {
+            metadata.filterDefinitionId = cache.searchForField(
+                'filterDefinition',
+                metadata.r__filterDefinition_CustomerKey,
+                'CustomerKey',
+                'ObjectID'
+            );
+            delete metadata.r__filterDefinition_CustomerKey;
+        }
+
+        // source
+        if (metadata.sourceTypeId === 1) {
+            // list
+        } else if (metadata.r__source_dataExtension_CustomerKey) {
+            // dataExtension
+            metadata.sourceObjectId = cache.searchForField(
+                'dataExtension',
+                metadata.r__source_dataExtension_CustomerKey,
+                'CustomerKey',
+                'ObjectID'
+            );
+            metadata.sourceTypeId = 2;
+            delete metadata.r__source_dataExtension_CustomerKey;
+        } else {
+            // assume the type id is still in the metadata
+            throw new Error(
+                ` - Filter '${metadata.name}' (${metadata.customerKey}): Unsupported source type ${
+                    metadata.sourceTypeId
+                }=${dataTypes[metadata.sourceTypeId]}`
+            );
+        }
+
+        // target
+        if (metadata.destinationTypeId === 1) {
+            // list
+        } else if (metadata.r__destination_dataExtension_CustomerKey) {
+            // dataExtension
+            metadata.destinationObjectId = cache.searchForField(
+                'dataExtension',
+                metadata.r__destination_dataExtension_CustomerKey,
+                'CustomerKey',
+                'ObjectID'
+            );
+            metadata.destinationTypeId = 2;
+            delete metadata.r__destination_dataExtension_CustomerKey;
+        } else {
+            // assume the type id is still in the metadata
+            throw new Error(
+                ` - Filter '${metadata.name}' (${
+                    metadata.customerKey
+                }): Unsupported destination type ${metadata.destinationTypeId}=${
+                    dataTypes[metadata.destinationTypeId]
+                }`
+            );
+        }
+
+        return metadata;
+    }
 }
 
 // Assign definition to static attributes