mcdev 3.0.0 → 3.1.0

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 };
     }
 
@@ -180,7 +230,7 @@ class Automation extends MetadataType {
             // eq-operator returns a similar, not exact match and hence might return more than 1 entry
             const [metadata] = results.filter((item) => item.Name === name);
             if (!metadata) {
-                Util.logger.error(`No ${this.definition.typeName} found with name "${name}"`);
+                Util.logger.error(`${this.definition.type} '${name}' not found on server.`);
                 return;
             }
             const details = (
@@ -217,7 +267,9 @@ class Automation extends MetadataType {
             );
             return { metadata: val, type: this.definition.type };
         } else if (results) {
-            throw new Error(`No Automations Found with name '${name}'`);
+            Util.logger.error(`${this.definition.type} '${name}' not found on server.`);
+            Util.logger.info(`Downloaded: automation (0)`);
+            return { metadata: {}, type: this.definition.type };
         } else {
             throw new Error(JSON.stringify(results));
         }
@@ -313,9 +365,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`
@@ -433,44 +484,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(
@@ -682,9 +745,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`
@@ -778,6 +840,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;