mcdev 3.0.2 → 3.1.2

package/lib/metadataTypes/Automation.js

@@ -92,14 +92,10 @@ class Automation extends MetadataType {
      * @returns {Promise<{metadata:AutomationMap,type:string}>} Promise of metadata
      */
     static async retrieve(retrieveDir) {
-        const results = await new Promise((resolve) => {
-            this.client.SoapClient.retrieve('Program', ['ObjectID'], (error, response) => {
-                if (error) {
-                    throw new Error(error);
-                } else {
-                    resolve(response.body.Results);
-                }
-            });
+        const results = await new Promise((resolve, reject) => {
+            this.client.SoapClient.retrieve('Program', ['ObjectID'], (ex, response) =>
+                ex ? reject(ex) : resolve(response.body.Results)
+            );
         });
         const details = (
             await Promise.all(
@@ -116,6 +112,60 @@ class Automation extends MetadataType {
         Util.logger.info(
             `Downloaded: ${this.definition.type} (${Object.keys(savedMetadata).length})`
         );
+        return { metadata: savedMetadata, type: this.definition.type };
+    }
+    /**
+     * Retrieves Metadata of Automation
+     * @returns {Promise<{metadata:AutomationMap,type:string}>} Promise of metadata
+     */
+    static async retrieveChangelog() {
+        const results = await new Promise((resolve, reject) => {
+            this.client.SoapClient.retrieve(
+                'Program',
+                ['ObjectID'],
+
+                (ex, response) => (ex ? reject(ex) : resolve(response.body.Results))
+            );
+        });
+        const details = [];
+        (
+            await Promise.all(
+                results.map(async (a) => {
+                    const options = {
+                        filter: {
+                            leftOperand: 'ProgramID',
+                            operator: 'equals',
+                            rightOperand: a.ObjectID,
+                        },
+                    };
+
+                    return new Promise((resolve, reject) => {
+                        this.client.SoapClient.retrieve(
+                            'Automation',
+                            [
+                                'ProgramID',
+                                'Name',
+                                'CustomerKey',
+                                'LastSaveDate',
+                                'LastSavedBy',
+                                'CreatedBy',
+                                'CreatedDate',
+                            ],
+                            options,
+                            (ex, response) => (ex ? reject(ex) : resolve(response.body.Results))
+                        );
+                    });
+                })
+            )
+        ).forEach((item) => {
+            details.push(...item);
+        });
+        details.map((item) => {
+            item.key = item.CustomerKey;
+        });
+
+        const parsed = this.parseResponseBody({ items: details });
+
         return { metadata: parsed, type: this.definition.type };
     }
 
@@ -152,10 +202,10 @@ class Automation extends MetadataType {
      * Retrieve a specific Automation Definition by Name
      * @param {string} templateDir Directory where retrieved metadata directory will be saved
      * @param {string} name name of the metadata file
-     * @param {Util.TemplateMap} variables variables to be replaced in the metadata
+     * @param {Util.TemplateMap} templateVariables variables to be replaced in the metadata
      * @returns {Promise<{metadata:AutomationMap,type:string}>} Promise of metadata
      */
-    static async retrieveAsTemplate(templateDir, name, variables) {
+    static async retrieveAsTemplate(templateDir, name, templateVariables) {
         const results = await new Promise((resolve) => {
             this.client.SoapClient.retrieve(
                 'Program',
@@ -189,12 +239,14 @@ class Automation extends MetadataType {
                 })
             ).body;
             let val = null;
+            let originalKey;
             // if parsing fails, we should just save what we get
             try {
                 const parsedDetails = this.parseMetadata(details);
+                originalKey = parsedDetails[this.definition.keyField];
                 if (parsedDetails !== null) {
                     val = JSON.parse(
-                        Util.replaceByObject(JSON.stringify(parsedDetails), variables)
+                        Util.replaceByObject(JSON.stringify(parsedDetails), templateVariables)
                     );
                 }
             } catch (ex) {
@@ -209,7 +261,7 @@ class Automation extends MetadataType {
             this.keepTemplateFields(val);
             File.writeJSONToFile(
                 [templateDir, this.definition.type].join('/'),
-                val[this.definition.keyField] + '.' + this.definition.type + '-meta',
+                originalKey + '.' + this.definition.type + '-meta',
                 val
             );
             Util.logger.info(
@@ -315,9 +367,8 @@ class Automation extends MetadataType {
                 delete metadata.schedule.scheduledTime;
                 delete metadata.schedule.scheduledStatus;
                 if (this.definition.timeZoneMapping[metadata.schedule.timezoneName]) {
-                    metadata.schedule.timezoneId = this.definition.timeZoneMapping[
-                        metadata.schedule.timezoneName
-                    ];
+                    metadata.schedule.timezoneId =
+                        this.definition.timeZoneMapping[metadata.schedule.timezoneName];
                 } else {
                     Util.logger.error(
                         `Could not find timezone ${metadata.schedule.timezoneName} in definition.timeZoneMapping`
@@ -435,44 +486,56 @@ class Automation extends MetadataType {
                     }
                     if (schedule !== null) {
                         try {
-                            await new Promise((resolve, reject) => {
-                                this.client.SoapClient.schedule(
-                                    'Automation',
-                                    schedule,
-                                    {
-                                        Interaction: {
-                                            ObjectID: metadata[key].id,
-                                        },
-                                    },
-                                    'start',
-                                    null,
-                                    (error, response) => {
-                                        if (
-                                            error ||
-                                            (response.body.Results &&
-                                                response.body.Results[0] &&
-                                                response.body.Results[0].StatusCode &&
-                                                response.body.Results[0].StatusCode === 'Error')
-                                        ) {
-                                            reject(error || response.body.Results[0].StatusMessage);
-                                        } else {
-                                            resolve(response.body.Results);
-                                        }
-                                    }
-                                );
-                            });
-                            const intervalString =
-                                (schedule._interval > 1 ? `${schedule._interval} ` : '') +
-                                (schedule.RecurrenceType === 'Daily'
-                                    ? 'Day'
-                                    : schedule.RecurrenceType.slice(0, -2) +
-                                      (schedule._interval > 1 ? 's' : ''));
-                            Util.logger.warn(
-                                `Automation '${
-                                    originalMetadata[key].name
-                                }' deployed Active: runs every ${intervalString} starting ${
-                                    schedule._StartDateTime.split('T').join(' ').split('.')[0]
-                                } ${schedule._timezoneString}`
+                            await Util.retryOnError(
+                                `Retrying ${this.definition.type}`,
+                                async () => {
+                                    await new Promise((resolve, reject) => {
+                                        this.client.SoapClient.schedule(
+                                            'Automation',
+                                            schedule,
+                                            {
+                                                Interaction: {
+                                                    ObjectID: metadata[key].id,
+                                                },
+                                            },
+                                            'start',
+                                            null,
+                                            (error, response) => {
+                                                if (
+                                                    error ||
+                                                    (response.body.Results &&
+                                                        response.body.Results[0] &&
+                                                        response.body.Results[0].StatusCode &&
+                                                        response.body.Results[0].StatusCode ===
+                                                            'Error')
+                                                ) {
+                                                    reject(
+                                                        error ||
+                                                            response.body.Results[0].StatusMessage
+                                                    );
+                                                } else {
+                                                    resolve(response.body.Results);
+                                                }
+                                            }
+                                        );
+                                    });
+                                    const intervalString =
+                                        (schedule._interval > 1 ? `${schedule._interval} ` : '') +
+                                        (schedule.RecurrenceType === 'Daily'
+                                            ? 'Day'
+                                            : schedule.RecurrenceType.slice(0, -2) +
+                                              (schedule._interval > 1 ? 's' : ''));
+                                    Util.logger.warn(
+                                        `Automation '${
+                                            originalMetadata[key].name
+                                        }' deployed Active: runs every ${intervalString} starting ${
+                                            schedule._StartDateTime
+                                                .split('T')
+                                                .join(' ')
+                                                .split('.')[0]
+                                        } ${schedule._timezoneString}`
+                                    );
+                                }
                             );
                         } catch (ex) {
                             Util.logger.error(
@@ -684,9 +747,8 @@ class Automation extends MetadataType {
         }
 
         if (this.definition.timeZoneMapping[scheduleObject.timezoneName]) {
-            scheduleObject.timezoneId = this.definition.timeZoneMapping[
-                scheduleObject.timezoneName
-            ];
+            scheduleObject.timezoneId =
+                this.definition.timeZoneMapping[scheduleObject.timezoneName];
         } else {
             Util.logger.error(
                 `Could not find timezone ${scheduleObject.timezoneName} in definition.timeZoneMapping`
@@ -780,6 +842,9 @@ class Automation extends MetadataType {
 // Assign definition to static attributes
 Automation.definition = Definitions.automation;
 Automation.cache = {};
+/**
+ * @type {Util.ET_Client}
+ */
 Automation.client = undefined;
 
 module.exports = Automation;