mcdev 3.0.2 → 3.1.2

package/lib/metadataTypes/DataExtract.js

@@ -30,10 +30,10 @@ class DataExtract extends MetadataType {
      * Retrieve a specific dataExtract Definition by Name
      * @param {String} templateDir Directory where retrieved metadata directory will be saved
      * @param {String} name name of the metadata file
-     * @param {Object} variables variables to be replaced in the metadata
+     * @param {Object} templateVariables variables to be replaced in the metadata
      * @returns {Promise<Object>} Promise of metadata
      */
-    static async retrieveAsTemplate(templateDir, name, variables) {
+    static async retrieveAsTemplate(templateDir, name, templateVariables) {
         const options = {
             uri: '/automation/v1/dataextracts/?$filter=name%20eq%20' + name.split(' ').join('%20'),
         };
@@ -51,16 +51,20 @@ class DataExtract extends MetadataType {
             const extended = await this.client.RestClient.get({
                 uri: '/automation/v1/dataextracts/' + metadata.id,
             });
+            const originalKey = extended.body[this.definition.keyField];
             const val = JSON.parse(
-                Util.replaceByObject(JSON.stringify(this.parseMetadata(extended.body)), variables)
+                Util.replaceByObject(
+                    JSON.stringify(this.parseMetadata(extended.body)),
+                    templateVariables
+                )
             );
 
             // remove all fields listed in Definition for templating
             this.keepTemplateFields(val);
             File.writeJSONToFile(
                 [templateDir, this.definition.type].join('/'),
-                val.customerKey + '.' + this.definition.type + '-meta',
-                JSON.parse(Util.replaceByObject(JSON.stringify(val), variables))
+                originalKey + '.' + this.definition.type + '-meta',
+                JSON.parse(Util.replaceByObject(JSON.stringify(val), templateVariables))
             );
             Util.logger.info(
                 `Dataextracts.retrieveAsTemplate:: Written Metadata to filesystem (${name})`

package/lib/metadataTypes/EventDefinition.js

@@ -32,10 +32,10 @@ class EventDefinition extends MetadataType {
      * Retrieve a specific Event Definition by Name
      * @param {String} templateDir Directory where retrieved metadata directory will be saved
      * @param {String} name name of the metadata file
-     * @param {Object} variables variables to be replaced in the metadata
+     * @param {Object} templateVariables variables to be replaced in the metadata
      * @returns {Promise<Object>} Promise of metadata
      */
-    static async retrieveAsTemplate(templateDir, name, variables) {
+    static async retrieveAsTemplate(templateDir, name, templateVariables) {
         // todo template based on name
         const options = {
             uri: '/interaction/v1/EventDefinitions?name=' + encodeURIComponent(name),
@@ -51,8 +51,12 @@ class EventDefinition extends MetadataType {
                         `please rename to be unique to avoid issues`
                 );
             } else if (event && event.length === 1) {
+                const originalKey = event[0][this.definition.keyField];
                 const eventDef = JSON.parse(
-                    Util.replaceByObject(JSON.stringify(this.parseMetadata(event[0])), variables)
+                    Util.replaceByObject(
+                        JSON.stringify(this.parseMetadata(event[0])),
+                        templateVariables
+                    )
                 );
                 if (!eventDef.dataExtensionId) {
                     throw new Error(
@@ -67,8 +71,8 @@ class EventDefinition extends MetadataType {
                 this.keepTemplateFields(eventDef);
                 File.writeJSONToFile(
                     [templateDir, this.definition.type].join('/'),
-                    eventDef.customerKey + '.' + this.definition.type + '-meta',
-                    JSON.parse(Util.replaceByObject(JSON.stringify(eventDef), variables))
+                    originalKey + '.' + this.definition.type + '-meta',
+                    JSON.parse(Util.replaceByObject(JSON.stringify(eventDef), templateVariables))
                 );
                 Util.logger.info(
                     `EventDefinition.retrieveAsTemplate:: Written Metadata to filesystem (${name})`

package/lib/metadataTypes/FileTransfer.js

@@ -30,10 +30,10 @@ class FileTransfer extends MetadataType {
      * Retrieve a specific File Transfer Definition by Name
      * @param {String} templateDir Directory where retrieved metadata directory will be saved
      * @param {String} name name of the metadata file
-     * @param {Object} variables variables to be replaced in the metadata
+     * @param {Object} templateVariables variables to be replaced in the metadata
      * @returns {Promise} Promise
      */
-    static async retrieveAsTemplate(templateDir, name, variables) {
+    static async retrieveAsTemplate(templateDir, name, templateVariables) {
         const options = {
             uri: '/automation/v1/filetransfers/?$filter=name%20eq%20' + name.split(' ').join('%20'),
         };
@@ -51,16 +51,20 @@ class FileTransfer extends MetadataType {
             const extended = await this.client.RestClient.get({
                 uri: '/automation/v1/filetransfers/' + metadata.id,
             });
+            const originalKey = extended.body[this.definition.keyField];
             const val = JSON.parse(
-                Util.replaceByObject(JSON.stringify(this.parseMetadata(extended.body)), variables)
+                Util.replaceByObject(
+                    JSON.stringify(this.parseMetadata(extended.body)),
+                    templateVariables
+                )
             );
 
             // remove all fields listed in Definition for templating
             this.keepTemplateFields(val);
             File.writeJSONToFile(
                 [templateDir, this.definition.type].join('/'),
-                val.customerKey + '.' + this.definition.type + '-meta',
-                JSON.parse(Util.replaceByObject(JSON.stringify(val), variables))
+                originalKey + '.' + this.definition.type + '-meta',
+                JSON.parse(Util.replaceByObject(JSON.stringify(val), templateVariables))
             );
             Util.logger.info(
                 `FileTransfer.retrieveAsTemplate:: Written Metadata to filesystem (${name})`

package/lib/metadataTypes/Folder.js

@@ -13,16 +13,16 @@ class Folder extends MetadataType {
     /**
      * Retrieves metadata of metadata type into local filesystem. executes callback with retrieved metadata
      * @param {String} retrieveDir Directory where retrieved metadata directory will be saved
-     * @param {String[]} [overrideFields] Returns specified fields even if their retrieve definition is not set to true
+     * @param {String[]} [additionalFields] Returns specified fields even if their retrieve definition is not set to true
      * @param {Object} buObject properties for auth
      * @returns {Promise} Promise
      */
-    static async retrieve(retrieveDir, overrideFields, buObject) {
-        const queryAllFolders = await this.retrieveHelper(overrideFields, true);
+    static async retrieve(retrieveDir, additionalFields, buObject) {
+        const queryAllFolders = await this.retrieveHelper(additionalFields, true);
         // if this is the parent, no need to query twice as QueryAllAccounts works.
 
         if (buObject.eid !== buObject.mid) {
-            queryAllFolders.push(...(await this.retrieveHelper(overrideFields, false)));
+            queryAllFolders.push(...(await this.retrieveHelper(additionalFields, false)));
         }
         const sortPairs = toposort(queryAllFolders.map((a) => [a.ParentFolder.ID, a.ID]));
         const idMap = {};
@@ -258,39 +258,36 @@ class Folder extends MetadataType {
      * @param {Object} metadata metadata of the folder
      * @returns {Promise} Promise
      */
-    static create(metadata) {
-        const tempCustomerKey = metadata.CustomerKey;
+    static async create(metadata) {
+        if (metadata.Parent && metadata.Parent.ID && metadata.Parent.ID === 0) {
+            Util.logger.error(
+                `${this.definition.type}-${metadata.ContentType}.create:: Cannot create Root Folder: ${metadata.Name}`
+            );
+            return {};
+        }
         const path = metadata.Path;
-        this.removeNotCreateableFields(metadata);
-        return new Promise((resolve) => {
-            if (metadata.Parent && metadata.Parent.ID && metadata.Parent.ID === 0) {
+        try {
+            const response = await super.createSOAP(metadata, 'DataFolder', true);
+            if (response) {
+                response.body.Results[0].Object = metadata;
+                response.body.Results[0].Object.ID = response.body.Results[0].NewID;
+                response.body.Results[0].Object.CustomerKey = metadata.CustomerKey;
+                delete response.body.Results[0].Object.$;
+
+                Util.logger.info(`- created folder: ${path}`);
+                return response;
+            }
+        } catch (ex) {
+            if (ex && ex.results) {
                 Util.logger.error(
-                    `${this.definition.type}-${metadata.ContentType}.create:: Cannot create Root Folder: ${metadata.Name}`
+                    `${this.definition.type}-${metadata.ContentType}.create:: error creating: '${path}'. ${ex.results[0].StatusMessage}`
+                );
+            } else if (ex) {
+                Util.logger.error(
+                    `${this.definition.type}-${metadata.ContentType}.create:: error creating: '${path}'. ${ex.message}`
                 );
-                resolve({});
-            } else {
-                this.client.SoapClient.create('DataFolder', metadata, null, (ex, response) => {
-                    if (ex && ex.results) {
-                        Util.logger.error(
-                            `${this.definition.type}-${metadata.ContentType}.create:: error creating: ${path}. ${ex.results[0].StatusMessage}`
-                        );
-                        resolve();
-                    } else if (ex) {
-                        Util.logger.error(
-                            `${this.definition.type}-${metadata.ContentType}.create:: error creating: ${path}. ${ex.message}`
-                        );
-                        resolve();
-                    } else {
-                        response.body.Results[0].Object = metadata;
-                        response.body.Results[0].Object.ID = response.body.Results[0].NewID;
-                        response.body.Results[0].Object.CustomerKey = tempCustomerKey;
-                        delete response.body.Results[0].Object.$;
-                        Util.logger.info(`- created folder: ${path}`);
-                        resolve(response);
-                    }
-                });
             }
-        });
+        }
     }
 
     /**
@@ -299,30 +296,27 @@ class Folder extends MetadataType {
      * @returns {Promise} Promise
      */
     static async update(metadata) {
-        return await new Promise((resolve) => {
-            const tempCustomerKey = metadata.CustomerKey;
-            const path = metadata.Path;
-            this.removeNotUpdateableFields(metadata);
-            this.client.SoapClient.update('DataFolder', metadata, null, (ex, response) => {
-                if (ex && ex.results) {
-                    Util.logger.error(
-                        `${this.definition.type}-${metadata.ContentType}.update:: error updating: '${path}'. ${ex.results[0].StatusMessage}`
-                    );
-                    resolve();
-                } else if (ex) {
-                    Util.logger.error(
-                        `${this.definition.type}-${metadata.ContentType}.update:: error updating: '${path}'. ${ex.message}`
-                    );
-                    resolve();
-                } else {
-                    response.body.Results[0].Object = metadata;
-                    response.body.Results[0].Object.CustomerKey = tempCustomerKey;
-                    delete response.body.Results[0].Object.$;
-                    Util.logger.info(`- updated folder: ${path}`);
-                    resolve(response);
-                }
-            });
-        });
+        const path = metadata.Path;
+        try {
+            const response = await super.updateSOAP(metadata, 'DataFolder', true);
+            if (response) {
+                response.body.Results[0].Object = metadata;
+                response.body.Results[0].Object.CustomerKey = metadata.CustomerKey;
+                delete response.body.Results[0].Object.$;
+                Util.logger.info(`- updated folder: ${path}`);
+                return response;
+            }
+        } catch (ex) {
+            if (ex && ex.results) {
+                Util.logger.error(
+                    `${this.definition.type}-${metadata.ContentType}.update:: error updating: '${path}'. ${ex.results[0].StatusMessage}`
+                );
+            } else if (ex) {
+                Util.logger.error(
+                    `${this.definition.type}-${metadata.ContentType}.update:: error updating: '${path}'. ${ex.message}`
+                );
+            }
+        }
     }
 
     /**
@@ -451,25 +445,28 @@ class Folder extends MetadataType {
 
     /**
      * Helper to retrieve the folders as promise
-     * @param {String[]} [overrideFields] Returns specified fields even if their retrieve definition is not set to true
+     * @param {String[]} [additionalFields] Returns specified fields even if their retrieve definition is not set to true
      * @param {Boolean} [queryAllAccounts] which queryAllAccounts setting to use
      * @returns {Promise<Object>} soap object
      */
-    static async retrieveHelper(overrideFields, queryAllAccounts) {
+    static async retrieveHelper(additionalFields, queryAllAccounts) {
         const options = { queryAllAccounts: !!queryAllAccounts };
         let status = 'MoreDataAvailable';
         const Results = [];
         do {
-            const response = await new Promise((resolve, reject) => {
-                // filtered out path as we need them to be stored locally, but do not want to try and retrieve
-                this.client.SoapClient.retrieve(
-                    'DataFolder',
-                    this.getFieldNamesToRetrieve(overrideFields).filter(
-                        (field) => !field.includes('Path')
-                    ),
-                    options,
-                    (ex, response) => (ex ? reject(ex) : resolve(response))
-                );
+            let response;
+            await Util.retryOnError(`Retrying ${this.definition.type}`, async () => {
+                response = await new Promise((resolve, reject) => {
+                    // filtered out path as we need them to be stored locally, but do not want to try and retrieve
+                    this.client.SoapClient.retrieve(
+                        'DataFolder',
+                        this.getFieldNamesToRetrieve(additionalFields).filter(
+                            (field) => !field.includes('Path')
+                        ),
+                        options,
+                        (ex, response) => (ex ? reject(ex) : resolve(response))
+                    );
+                });
             });
             // merge results with existing
             Results.push(...response.body.Results);

package/lib/metadataTypes/ImportFile.js

@@ -32,10 +32,10 @@ class ImportFile extends MetadataType {
      * Retrieve a specific Import Definition by Name
      * @param {String} templateDir Directory where retrieved metadata directory will be saved
      * @param {String} name name of the metadata file
-     * @param {Object} variables variables to be replaced in the metadata
+     * @param {Object} templateVariables variables to be replaced in the metadata
      * @returns {Promise} Promise
      */
-    static async retrieveAsTemplate(templateDir, name, variables) {
+    static async retrieveAsTemplate(templateDir, name, templateVariables) {
         const options = {
             uri: '/automation/v1/imports/?$filter=name%20eq%20' + name.split(' ').join('%20'),
         };
@@ -48,17 +48,20 @@ class ImportFile extends MetadataType {
                 Util.logger.error(`No ${this.definition.typeName} found with name "${name}"`);
                 return;
             }
-
+            const originalKey = metadata[this.definition.keyField];
             const val = JSON.parse(
-                Util.replaceByObject(JSON.stringify(this.parseMetadata(metadata)), variables)
+                Util.replaceByObject(
+                    JSON.stringify(this.parseMetadata(metadata)),
+                    templateVariables
+                )
             );
 
             // remove all fields listed in Definition for templating
             this.keepTemplateFields(val);
             File.writeJSONToFile(
                 [templateDir, this.definition.type].join('/'),
-                val.customerKey + '.' + this.definition.type + '-meta',
-                JSON.parse(Util.replaceByObject(JSON.stringify(val), variables))
+                originalKey + '.' + this.definition.type + '-meta',
+                JSON.parse(Util.replaceByObject(JSON.stringify(val), templateVariables))
             );
             Util.logger.info(
                 `ImportFile.retrieveAsTemplate:: Written Metadata to filesystem (${name})`
@@ -147,12 +150,10 @@ class ImportFile extends MetadataType {
             }
         }
         // When the destinationObjectTypeId is 584 is refers to Mobile Connect which is not supported as an Import Type
-        metadata.destinationObjectTypeId = this.definition.destinationObjectTypeMapping[
-            metadata.c__destinationType
-        ];
-        metadata.subscriberImportTypeId = this.definition.subscriberImportTypeMapping[
-            metadata.c__subscriberImportType
-        ];
+        metadata.destinationObjectTypeId =
+            this.definition.destinationObjectTypeMapping[metadata.c__destinationType];
+        metadata.subscriberImportTypeId =
+            this.definition.subscriberImportTypeMapping[metadata.c__subscriberImportType];
         metadata.updateTypeId = this.definition.updateTypeMapping[metadata.c__dataAction];
         return metadata;
     }