Feature/9 add filterDefinition & resolve filter details

lib/MetadataTypeDefinitions.js

@@ -21,6 +21,7 @@ const MetadataTypeDefinitions = {
     eventDefinition: require('./metadataTypes/definitions/EventDefinition.definition'),
     fileTransfer: require('./metadataTypes/definitions/FileTransfer.definition'),
     filter: require('./metadataTypes/definitions/Filter.definition'),
+    filterDefinition: require('./metadataTypes/definitions/FilterDefinition.definition'),
     folder: require('./metadataTypes/definitions/Folder.definition'),
     ftpLocation: require('./metadataTypes/definitions/FtpLocation.definition'),
     importFile: require('./metadataTypes/definitions/ImportFile.definition'),

lib/MetadataTypeInfo.js

@@ -21,6 +21,7 @@ const MetadataTypeInfo = {
     eventDefinition: require('./metadataTypes/EventDefinition'),
     fileTransfer: require('./metadataTypes/FileTransfer'),
     filter: require('./metadataTypes/Filter'),
+    filterDefinition: require('./metadataTypes/FilterDefinition'),
     folder: require('./metadataTypes/Folder'),
     ftpLocation: require('./metadataTypes/FtpLocation'),
     importFile: require('./metadataTypes/ImportFile'),

lib/metadataTypes/Filter.js

@@ -1,6 +1,32 @@
 'use strict';
 
+/**
+ * @typedef {Object} FilterItem
+ * @property {number} categoryId folder id
+ * @property {string} [createdDate] -
+ * @property {string} customerKey key
+ * @property {string} destinationObjectId DE/List ID
+ * @property {1|2|3|4} destinationTypeId 1:SubscriberList, 2:DataExtension, 3:GroupWizard, 4:BehavioralData
+ * @property {string} filterActivityId ?
+ * @property {string} filterDefinitionId ObjectID of filterDefinition
+ * @property {string} modifiedDate -
+ * @property {string} name name
+ * @property {string} sourceObjectId DE/List ID
+ * @property {1|2|3|4} sourceTypeId 1:SubscriberList, 2:DataExtension, 3:GroupWizard, 4:BehavioralData
+ * @property {number} statusId ?
+ *
+ * @typedef {Object.<string, FilterItem>} FilterMap
+ */
+
 const MetadataType = require('./MetadataType');
+const Util = require('../util/util');
+
+const dataTypes = {
+    1: 'List',
+    2: 'DataExtension',
+    3: 'Group Wizard',
+    4: 'Behavioral Data',
+};
 
 /**
  * Filter MetadataType
@@ -13,11 +39,176 @@ class Filter extends MetadataType {
      * but only with some of the fields. So it is needed to loop over
      * Filters with the endpoint /automation/v1/filters/{id}
      * @param {String} retrieveDir Directory where retrieved metadata directory will be saved
-     * @returns {Promise} Promise
+     * @returns {Promise<{metadata:FilterMap,type:string}>} Promise of items
      */
     static async retrieve(retrieveDir) {
         return super.retrieveREST(retrieveDir, '/automation/v1/filters/', null);
     }
+    /**
+     * manages post retrieve steps
+     * @param {FilterItem} item a single record
+     * @returns {FilterItem} parsed metadata definition
+     */
+    static postRetrieveTasks(item) {
+        return this.parseMetadata(item);
+    }
+    /**
+     * parses retrieved Metadata before saving
+     * @param {FilterItem} metadata a single record
+     * @returns {FilterItem} parsed metadata definition
+     */
+    static parseMetadata(metadata) {
+        try {
+            // folder
+            metadata.r__folder_Path = Util.getFromCache(
+                this.cache,
+                'folder',
+                metadata.categoryId,
+                'ID',
+                'Path'
+            );
+            delete metadata.categoryId;
+
+            // filterDefinition
+            metadata.r__filterDefinition_CustomerKey = Util.getFromCache(
+                this.cache,
+                'filterDefinition',
+                metadata.filterDefinitionId,
+                'id',
+                'key'
+            );
+            delete metadata.filterDefinitionId;
+
+            // source
+            if (metadata.sourceTypeId === 1) {
+                // list
+            } else if (metadata.sourceTypeId === 2) {
+                // dataExtension
+                metadata.r__source_dataExtension_CustomerKey = Util.getFromCache(
+                    this.cache,
+                    'dataExtension',
+                    metadata.sourceObjectId,
+                    'ObjectID',
+                    'CustomerKey'
+                );
+                delete metadata.sourceObjectId;
+                delete metadata.sourceTypeId;
+            } else {
+                Util.logger.error(
+                    `Filter '${metadata.name}' (${metadata.customerKey}): Unsupported source type ${
+                        metadata.sourceTypeId
+                    }=${dataTypes[metadata.sourceTypeId]}`
+                );
+            }
+
+            // target
+            if (metadata.destinationTypeId === 1) {
+                // list
+            } else if (metadata.destinationTypeId === 2) {
+                // dataExtension
+                metadata.r__destination_dataExtension_CustomerKey = Util.getFromCache(
+                    this.cache,
+                    'dataExtension',
+                    metadata.destinationObjectId,
+                    'ObjectID',
+                    'CustomerKey'
+                );
+                delete metadata.destinationObjectId;
+                delete metadata.destinationTypeId;
+            } else {
+                Util.logger.error(
+                    `Filter '${metadata.name}' (${
+                        metadata.customerKey
+                    }): Unsupported destination type ${metadata.destinationTypeId}=${
+                        dataTypes[metadata.destinationTypeId]
+                    }`
+                );
+            }
+        } catch (ex) {
+            Util.logger.error(`Filter '${metadata.name}' (${metadata.customerKey}): ${ex.message}`);
+        }
+        return metadata;
+    }
+    /**
+     * prepares a record for deployment
+     * @param {FilterItem} metadata a single record
+     * @returns {Promise<FilterItem>} Promise of updated single record
+     */
+    static async preDeployTasks(metadata) {
+        // folder
+        if (metadata.r__folder_Path) {
+            metadata.categoryId = Util.getFromCache(
+                this.cache,
+                'folder',
+                metadata.r__folder_Path,
+                'Path',
+                'ID'
+            );
+            delete metadata.r__folder_Path;
+        }
+
+        // filterDefinition
+        if (metadata.r__filterDefinition_CustomerKey) {
+            metadata.filterDefinitionId = Util.getFromCache(
+                this.cache,
+                '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 = Util.getFromCache(
+                this.cache,
+                '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 = Util.getFromCache(
+                this.cache,
+                '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